Info über Fehlermeldungen und Warnungen

Meldungen bestehen aus der Meldungsklasse, gefolgt vom Namen der Quelldatei und der Zeilennummer, in welcher der Fehler aufgetreten ist und schließlich aus der eigentlichen Meldung.

Die folgenden Meldungskategorien können auftreten:

Kategorie	Verweist auf:

Informativ	Informationen über den Verlauf eines Vorgangs, wie etwa des Erzeugungsprozesses.

Fehler	Ein Fehler, der behoben werden muß, etwa eine fehlende Deklaration oder ein Typkonflikt.

Warnung	Ein Problem, das übergangen werden kann.

Schwerwiegend	Ein schwerwiegender Fehler, der die weitere Ausführung des Programms unmöglich macht.

Beachten Sie bitte, daß der Compiler Meldungen immer dann erzeugt, wenn ein Fehler oder eine Warnung entdeckt wird. Da Sie in C und C++ keinerlei Beschränkung unterliegen, wie Sie Ihren Quelltext zu strukturieren haben, kann der eigentliche Grund für den Fehler oder die Warnung eine oder mehrere Zeilen vor oder nach der in der Meldung angegebenen Zeilennummer liegen.

Viele der Meldungen erscheinen in der Meldungsansicht. Für diese Meldungen ist eine kontextbezogene Hilfe verfügbar. Markieren Sie die Meldung und drücken Sie anschließend die Funktionstaste [F1], damit die Meldungsbeschreibung eingeblendet wird.

Falls Sie über die Kommandozeile arbeiten oder sich Informationen über eine Fehlermeldung ansehen möchten, finden Sie weitere Informationen unter Fehlermeldungen und Warnungen. Suchen Sie hier die Meldung, die Sie interessiert und klicken Sie dann auf die Meldung. Dadurch wird die Beschreibung der gewählten Meldung angezeigt.

Symbole

Einige Meldungen enthalten ein Symbol (beispielsweise eine Variable, ein Dateiname oder ein Modul), das durch einen Namen ersetzt wird, der in Ihrem Progamm enthaltenen ist. In dem folgenden Beispiel wird Dateiname durch den Namen der Datei, die das Problem verursacht hat, ersetzt:

Error opening 'filename' for output

Die folgende Liste enthält die in Fehlermeldungen und Warnungen verwendeten Symbole und deren Bedeutung:

Symbol	Bedeutung

address	Eine hexadezimale Zahl, welche die Adresse angibt, an welcher der Fehler auftrat

argument 	Ein Argument

class	Ein Klassenname

filename	Ein Dateiname (mit oder ohne Erweiterung)

function	Ein Funktionsname

group	Ein Gruppennname

identifier	Ein Bezeichner (Variablenname oder sonstiges)

language	Der Name der Programmiersprache

member	Der Name des Datenelements oder der Elementfunktion

message	Ein Meldungs-String

module	Ein Modulname

name	Ein beliebiger Name

num	Eine Zahl

number	Eine Zahl

option	Eine Option

parameter	Ein Paramatername

path	Ein Pfadname

reason	Der Grund der Meldung

segment	Ein Segmentname

size	Eine aktuelle Zahl

specifier	Ein Typbezeichner

symbol	Ein Symbolname

type	Ein Datentyp

variable	Eine Programmvariable

Einige Meldungen beginnen mit einem Symbolnamen, wie zum Beispiel:

'filename' not found

Diese Meldungen sind nach den Symbolnamen in alphabethischer Reihenfolge aufgelistet. Die Meldung aus dem obigen Beispiel würde demnach unter dem Buchstaben f aufgeführt.

Compiler Fehler und Warnungen

Fehlermeldungen, die zum Zeitpunkt des Compilierens auftreten, deuten auf Fehler in der Syntax des Programms, auf Fehler in der Befehlszeile oder auf Fehler beim Zugriff auf Diskette/Platte oder den Speicher hin. Bei den meisten Compiler-Fehlern beendet der Compiler die aktuelle Phase der Compilierung (Präprozessor, Parsen, Optimierung oder Code-Generierung) und hält an. Tritt jedoch ein schwerer Fehler auf, wird die Compilierung sofort abgebrochen. Berichtigen Sie Ihren Quelltext und starten Sie die Compilierung erneut.

Laufzeitfehler treten erst nach dem erfolgreichen Compilieren Ihres Programms auf, wenn es ausgeführt wird. Normalerweise bestehen Laufzeitfehler aus logischen Fehlern in Ihrem Programmquelltext. Erhalten Sie einen Laufzeitfehler, müssen Sie den Fehler in Ihrem Quelltext beheben und das Programm neu compilieren, damit die Änderungen wirksam werden.

Warnungen bedeuten, daß der Compiler auf Konstrukte stieß, die zwar fraglich, aber sprachlich zulässig sind, oder daß Sie maschinenabhängigen Code verwendet haben. Bei Warnungen wird die Compilierung nicht abgebrochen.

Es gibt folgende Gründe für die Ausgabe von Warnungen:

ANSI-Verletzungen	Sie haben Code verwendet, der zwar in C++Builder zulässig ist (weil es sich um C++ Code oder um C++Builder-Erweiterungen handelt), aber nicht in der ANSI-C Definition enthalten ist.

Häufige Warnungen	Verweisen auf häufige Programmierfehler. Diese Warnungen zeigen gewisse Bedingungen an, die keine Verletzung der C++Builder-Sprachdefinition darstellen, aber eventuell das falsche Ergebnis erbringen.

Weniger häufige Warnungen	Verweisen auf weniger häufige Programmierfehler. Diese Warnungen zeigen Bedingungen an, die keine Verletzung der C++Builder-Sprachdefinition darstellen, aber eventuell das falsche Ergebnis erbringen.

Portabilitätswarnungen	Verweisen auf mögliche Probleme bei der Portierung ihres Codes auf andere Compiler. Es handelt sich hierbei normalerweise um C++BuilderErweiterungen.

C++ Warnungen	Verweisen auf Fehler in Ihrem C++ Code, wie z.B. veraltete Befehle oder inkorrekte Syntax.

Laufzeitfehler und -warnungen

Laufzeitfehler treten erst nach der erfolgreichen Compilierung Ihres Codes auf, wenn das Programm abläuft.

Linkerfehler und -warnungen

In der Regel beenden Linkerfehler nicht die Ausführung des Linkers oder führen zum Löschen der erzeugten EXE- oder MAP-Dateien. Treten solche Fehler auf, sollten Sie die erzeugte EXE-Datei nicht versuchen auszuführen, sondern den Fehler beheben und dann das Programm neu linken.

Ein schwerer Linkerfehler führt jedoch zum Abbruch des Linkers und die EXE-Datei wird gelöscht. Compilieren Sie Ihr Programm in der integrierten Entwicklungsumgebung (IDE), werden alle Linkerfehler als schwere Fehler behandelt.

Linkerwarnungen deuten auf Bedingungen hin, die Sie beheben sollten. Tritt eine Warnung auf, werden die zugehörigen EXE- und MAP-Dateien jedoch trotzdem erzeugt.

Fehlermeldungen und Warnungen der Bibliotheksverwaltung

Diese Fehler und Warnungen treten auf, wenn es ein Problem mit Dateien oder erweiterten Verzeichnissen gibt, wenn der Arbeitsspeicher knapp wird, oder wenn es ein Problem beim Zugriff auf die Bibliotheken gibt.


Fehlermeldungen und Warnungen

Überblick

Sonderzeichen

#undef directive ignored—Compiler-Warnung

( expected—Compiler-Fehler

) expected—Compiler-Fehler

, expected—Compiler-Fehler

: expected after private—Compiler-Fehler

: expected after protected—Compiler-Fehler

: expected after public—Compiler-Fehler

< expected—Compiler-Fehler

> expected—Compiler-Fehler

@ seen, expected a response-files name—Fehler der Bibliotheksverwaltung

{ expected— Compiler-Fehler

} expected—Compiler-Fehler

16-bit segments not supported in module 'module'—Linker-Fehler

A

Abnormal program termination—Laufzeitfehler

Access can only be changed to public or protected—Compiler-Fehler

Access specifier of property identifier must be a member of function— Compiler-Fehler

Access violation. Program terminated—Inkrementeller Linker-Fehler

Added file 'filename' does not begin correctly, ignored—Warnung der Bibliotheksverwaltung

Address of overloaded function 'function' doesn't match 'type'—Compiler-Fehler

Ambiguity between 'function1' and 'function2'—Compiler-Fehler

Ambiguous member name 'name'—Compiler-Fehler

Ambiguous operators need parentheses—Compiler-Warnung

Ambiguous override of virtual base member 'function1': 'function2'—Compiler-Fehler

Application is running—Laufzeitfehler

Array allocated using 'new' may not have an initializer—Compiler-Fehler

Array bounds missing ]—Compiler-Fehler

Array must have at least one element—Compiler-Fehler

Array of references is not allowed—Compiler-Fehler

Array size for 'delete' ignored —Compiler-Warnung oder Compiler-Fehler

Array size too large—Compiler-Fehler

Array variable 'identifier' is near—Compiler-Warnung

Assembler stack overflow—Compiler-Fehler

Assembler statement too long—Compiler-Fehler

Assertion failed: module at '\address\', line number—Inkrementeller Linker-Fehler

Assigning 'type' to 'enumeration'—Compiler-Warnung

Assignment to 'this' not allowed, use X::operator new instead—Compiler-Fehler

Attempt to export non-public symbol 'symbol'—Linker-Fehler

Attempt to free NULL pointer in module, 'line number'— Inkrementeller Linker-Fehler

Attempt to grant or reduce access to 'identifier'—Compiler-Fehler

Attempting to return a reference to a local object—Compiler-Fehler

Attempting to return a reference to local variable 'identifier'—Compiler-Fehler

B

Bad call of intrinsic function—Compiler-Fehler

Bad character in parameters -> 'char'—Linker-Fehler

Bad 'directive' directive syntax—Compiler-Fehler

Bad field list in debug information in module 'module'—Linker-Fehler

Bad file name 'filename'—Linker-Fehler

Bad file name format in include directive—Compiler-Fehler

Bad filename format in include statement—MAKE-Fehler

Bad file name format in line directive—Compiler-Fehler

Bad GRPDEF type encountered, extended dictionary aborted—Warnung der Bibliotheksverwaltung

Bad header in input LIB—Fehler der Bibliotheksverwaltung

Bad LF_POINTER in module 'module'—Linker-Fehler

Bad loc for fixupp in module 'module' near file offset 'offset'—Linker-Fehler

Bad macro output translator—MAKE-Fehler

Bad object file 'filename' near file offset 'offset'—Linker-Fehler

Bad OMF record type 'type' encountered in module 'module'—Fehler der Bibliotheksverwaltung

Bad secondary target for fixup in module 'module'—Linker-Fehler

Bad syntax for pure function definition—Compiler-Fehler

Bad 'type' debug info in module 'module'—Linker-Fehler

Bad undef statement syntax—MAKE-Fehler

Base class 'class1' is also a base class of 'class2'—Compiler-Warnung

Base class 'class' contains dynamically dispatchable functions—Compiler-Fehler

Base class 'class' is inaccessible because also in 'class'—Compiler-Warnung

Base class 'class' is included more than once—Compiler-Fehler

Base class 'class' is initialized more than once—Compiler-Fehler

Base initialization without a class name is now obsolete—Compiler-Warnung

'base' is an indirect virtual base class of 'class'—Compiler-Fehler

Bit field cannot be static—Compiler-Fehler

Bit field too large—Compiler-Fehler

Bit fields must be signed or unsigned int—Compiler-Fehler

Bit fields must be signed or unsigned int—Compiler-Warnung

Bit fields must contain at least one bit—Compiler-Fehler

Bit fields must have integral type—Compiler-Fehler

Body has already been defined for function 'function'—Compiler-Fehler

Both return and return with a value used—Compiler-Warnung

C

Call of nonfunction—Compiler-Fehler

Call to function 'function' with no prototype—Compiler-Warnung

Call to function with no prototype—Compiler-Warnung

Call to undefined function 'function'—Compiler-Fehler

Can't grow LE/LIDATA record buffer—Fehler der Bibliotheksverwaltung

Can't inherit non-RTTI class from RTTI base 'class'—Compiler-Fehler

Can't inherit RTTI class from non-RTTI base 'class'—Compiler-Fehler

Cannot add or subtract relocatable symbols—Compiler-Fehler

Cannot allocate a reference—Compiler-Fehler

Cannot call 'main' from within the program—Compiler-Fehler

Cannot call near class member function with a pointer of type 'type'—Compiler-Fehler

Cannot cast from 'type1' to 'type2'—Compiler-Fehler

Cannot convert 'type1' to 'type2'—Compiler-Fehler

Cannot create instance of abstract class 'class'—Compiler-Fehler

Cannot create precompiled header: 'reason'—Compiler-Fehler

Cannot declare or define 'identifier' here—Compiler-Fehler

Cannot define a pointer or reference to a reference—Compiler-Fehler

Cannot define 'identifier' using a namespace alias—Compiler-Fehler

Cannot find 'class'::operator=('class'&) to copy a vector—Compiler-Fehler

Cannot find class::class (class &) to copy a vector—Compiler-Fehler

Cannot find default constructor to initialize array element of type 'class'—Compiler-Fehler

Cannot find default constructor to initialize base class 'class'—Compiler-Fehler

Cannot find default constructor to initialize member 'identifier'—Compiler-Fehler

Cannot find MAKE.EXE—MAKE-Fehler

Cannot find tasm program: tasm.exe—IDE-Fehler

Cannot generate 'function' from template function 'template'—Compiler-Fehler

Cannot have a non-inline function in a local class—Compiler-Fehler

Cannot have a static data in a local class—Compiler-Fehler

Cannot have multiple paths for implicit rule—MAKE-Fehler

Cannot have path list for target—MAKE-Fehler

Cannot inherit non-RTTI class from RTTI base—Compiler-Fehler

Cannot initialize 'type1' with 'type2'—Compiler-Fehler

Cannot initialize a class member here—Compiler-Fehler

Cannot locate file I/O hook functions for resource compiler—Ressourcen-Compiler-Fehler

Cannot Load Linker: linker—IDE-Fehler

Cannot modify a const object—Compiler-Fehler

Cannot overload 'main'—Compiler-Fehler

Cannot take address of 'main'—Compiler-Fehler

Cannot throw 'type' -- ambiguous base class 'base'—Compiler-Fehler

Cannot use local type 'identifier' as template argument—Compiler-Fehler

Cannot use tiny or huge memory model with Windows—Compiler-Fehler

Cannot write a string option—MAKE-Fehler

Cannot write GRPDEF list, extended dictionary aborted—Warnung der Bibliotheksverwaltung

Cannot write to disk—Inkrementeller Linker-Fehler

Case bypasses initialization of a local variable—Compiler-Fehler

Case outside of switch—Compiler-Fehler

Case statement missing :—Compiler-Fehler

'catch' expected —Compiler-Fehler

Character constant must be one or two characters long—Compiler-Fehler

Character constant too long—MAKE-Fehler

Circular dependency exists in makefile—MAKE-Fehler

Circular property definition :— Compiler-Fehler

Class 'class' may not contain pure functions—Compiler-Fehler

Class 'classname' is abstract because of 'member = 0'—Compiler-Fehler

Classid requires definition of ‘type’ as a pointer type— Compiler-Fehler

Class member 'member' declared outside its class—Compiler-Fehler

Code has no effect—Compiler-Warnung

CodeGuarded programs must use the large memory model and be targeted for Windows—Compiler-Fehler

Colon expected—MAKE-Fehler

Command arguments too long—MAKE-Fehler

Command syntax error—MAKE-Fehler

Comparing signed and unsigned values—Compiler-Warnung

Compiler could not generate copy constructor for class 'class'—Compiler-Fehler

Compiler could not generate default constructor for class 'class'—Compiler-Fehler

Compiler could not generate default destructor for class 'class'—Compiler-Fehler

Compiler could not generate operator = for class 'class'—Compiler-Fehler

Compiler stack overflow—Compiler-Fehler

Compiler table limit exceeded—Compiler-Fehler

Compound statement missing }—Compiler-Fehler

Condition is always false—Compiler-Warnung

Condition is always true—Compiler-Warnung

Conflicting type modifiers—Compiler-Fehler

Constant expression required—Compiler-Fehler

Constant is long—Compiler-Warnung

Constant member 'member' in class without constructors—Compiler-Fehler

Constant member 'member' is not initialized—Compiler-Warnung

Constant out of range in comparison—Compiler-Warnung

Constant variable 'variable' must be initialized—Compiler-Fehler

Constructor cannot be declared 'const' or 'volatile'—Compiler-Fehler

Constructor cannot have a return type specification—Compiler-Fehler

'constructor' is not an unambiguous base class of 'class'—Compiler-Fehler

Constructor initializer list ignored—Compiler-Warnung

Constructors and destructors not allowed in__automated section— Compiler-Fehler

Continuation character \ found in // comment—Compiler-Warnung

Conversion may lose significant digits—Compiler-Warnung

Conversion of near pointer not allowed—Compiler-Fehler

Conversion operator cannot have a return type specification—Compiler-Fehler

Conversion to 'type' will fail for members of virtual base 'class'—Compiler-Warnung

Conversions of class to itself or base class not allowed —Compiler-Fehler

Converting reference to external type ‘type’ to void —Linker-Warnung

Could not allocate memory for per module data—Fehler der Bibliotheksverwaltung

Could not create 'filename' (error code 'number')—Inkrementeller Linker-Fehler

Could not create list file 'filename'—Fehler der Bibliotheksverwaltung

Could not find a match for argument(s)—Compiler-Fehler

Could not find file 'filename'—Compiler-Fehler

Could not find object file 'filename'—Inkrementeller Linker-Fehler

Could not find precompiled type obj file 'filename'—Linker-Warnung

Could not get procedure address from RLINK32.DLL— Inkrementeller Linker-Fehler

Could not load RLINK32.DLL— Inkrementeller Linker-Fehler

Could not open 'filename' (error code 'number')— Inkrementeller Linker-Fehler

Could not open 'filename' (program still running?)— Inkrementeller Linker-Fehler

Could not open 'filename' (project already open in IDE?)— Inkrementeller Linker-Fehler

Could not write output—Fehler der Bibliotheksverwaltung

Couldn't get LE/LIDATA record buffer—Fehler der Bibliotheksverwaltung

Couldn't get procedure address from DLL 'dll'—Linker-Fehler

Couldn't load DLL 'dll'—Linker-Fehler

Cycle in include files: 'filename'—MAKE-Fehler

D

Data member definition not allowed in __automated section— Compiler-Fehler

Debug info switch ignored for COM files—Linker-Warnung

Debug information overflow in module ‘module’ near file— Linker-Fehler

Debug information enabled, but no debug information found in OBJs—Linker-Warnung

Declaration does not specify a tag or an identifier—Compiler-Fehler

Declaration ignored—Compiler-Warnung

Declaration is not allowed here—Compiler-Fehler

Declaration missing ;—Compiler-Fehler

Declaration of static function '(...)' ignored—Compiler-Warnung

Declaration syntax error—Compiler-Fehler

Declaration terminated incorrectly—Compiler-Fehler

Declaration was expected—Compiler-Fehler

Declare operator delete (void*) or (void*, size_t)—Compiler-Fehler

Declare operator delete[] (void*) or (void*, size_t)—Compiler-Fehler

Declare type 'type' prior to use in prototype—Compiler-Warnung

.DEF file heap reserve size < 64K; 1MB default will be used—Linker-Warnung

.DEF file stack reserve size < 64K; 1MB default will be used—Linker-Warnung

Default argument value redeclared—Compiler-Fehler

Default argument value redeclared for parameter 'parameter'—Compiler-Fehler

Default expression may not use local variables—Compiler-Fehler

Default outside of switch—Compiler-Fehler

Default value missing—Compiler-Fehler

Default value missing following parameter 'parameter'—Compiler-Fehler

Define directive needs an identifier—Compiler-Fehler

Delete array size missing ]—Compiler-Fehler

Destructor cannot be declared 'const' or 'volatile'—Compiler-Fehler

Destructor cannot have a return type specification—Compiler-Fehler

Destructor for 'class' required in conditional expression—Compiler-Fehler

Destructor for class is not accessible—Compiler-Fehler

Destructor name must match the class name—Compiler-Fehler

Dispid ‘number’ already used by ‘identifier’ Divide error— Compiler-Fehler

Dispid only allowed in __automated sections— Compiler-Fehler

Divide error—Laufzeitfehler

Division by zero—Compiler-Fehler

Division by zero—Compiler-Warnung

Division by zero—MAKE-Fehler

do statement must have while—Compiler-Fehler

do-while statement missing (—Compiler-Fehler

do-while statement missing )—Compiler-Fehler

do-while statement missing ;—Compiler-Fehler

DPMI programs must use the large memory model—Compiler-Fehler

Duplicate case—Compiler-Fehler

Duplicate file ' filename'  in list, not added!—Fehler der Bibliotheksverwaltung

Duplicate handler for 'type1', already had 'type2'—Compiler-Fehler

Duplicate ordinal for exports: 'string' ('ordval1') and 'string' ('ordval2')—Linker-Fehler

E

Earlier declaration of 'identifier'—Compiler-Fehler

End of system input buffer encountered—Linker-Fehler

Empty LEDATA record in module 'module'—Linker-Warnung

Enum syntax error—Compiler-Fehler

Error changing file buffer size—Fehler der Bibliotheksverwaltung

Error directive: 'message'—Compiler-Fehler

Error directive: 'message'—MAKE-Fehler

Error opening 'filename'—Fehler der Bibliotheksverwaltung

Error opening 'filename' for output—Fehler der Bibliotheksverwaltung

Error processing module 'module'—Inkrementeller Linker-Fehler

Error renaming 'filename' to 'filename'—Fehler der Bibliotheksverwaltung

Error writing output file—Compiler-Fehler

'__except' or '__finally' Expected Following '__try'—Compiler-Fehler

Exception handling not enabled—Compiler-Fehler

Exception handling variable may not be used here—Compiler-Fehler

Exception specification not allowed here—Compiler-Fehler

Explicit stacks are ignored for PE images—Linker-Warnung

Export 'symbol' has multiple ordinal values: 'value1' and 'value2'—Linker-Warnung

Export 'symbol' is duplicated—Linker-Warnung

Expression expected—Compiler-Fehler

Expression of scalar type expected—Compiler-Fehler

Expression syntax—Compiler-Fehler

Expression syntax error in !if statement—MAKE-Fehler

Extern 'symbol' was not qualified with __import in module 'module'—Linker-Warnung

Extern variable cannot be initialized—Compiler-Fehler

Extra argument in template class name 'template'—Compiler-Fehler

Extra parameter in call—Compiler-Fehler

Extra parameter in call to function—Compiler-Fehler

F

Failed to create map file 'filename' (error code 'number')—Inkrementeller Linker-Fehler

Failed read from 'filename'—Linker-Fehler

Failed write to 'filename'—Linker-Fehler

Far COMDEFs are not supported—Linker-Fehler

FATAL ERROR: Cannot Load Linker: 'linker'—IDE-Fehler

FATAL ERROR: Linker CREATE Failed— IDE-Fehler

FATAL ERROR: Linker missing CREATE Entry Point— IDE-Fehler

FATAL ERROR: Linker missing DESTROY Entry Point— IDE-Fehler

FATAL ERROR: GP FAULT—MAKE-Fehler

File must contain at least one external declaration—Compiler-Fehler

File name too long—Compiler-Fehler

Filename too long—MAKE-Fehler

'filename' couldn't be created, original won't be changed—Warnung der Bibliotheksverwaltung

'filename' does not exist—don't know how to make it—MAKE-Fehler

'filename' file not found—Fehler der Bibliotheksverwaltung

'filename' file not found—Warnung der Bibliotheksverwaltung

'filename' is not a valid library—Linker-Warnung

'filename' not a MAKE—MAKE-Fehler

Fixup to zero length segment in module 'module'—Linker-Fehler

Fixupps found for an LIDATA record—Linker-Fehler

Floating point error: Divide by 0—Laufzeitfehler

Floating point error: Domain—Laufzeitfehler

Floating point error: Overflow—Laufzeitfehler

Floating point error: Partial loss of precision—Laufzeitfehler

Floating point error: Stack fault—Laufzeitfehler

Floating point error: Underflow—Laufzeitfehler

For statement missing (—Compiler-Fehler

For statement missing )—Compiler-Fehler

For statement missing ;—Compiler-Fehler

Friends must be functions or classes—Compiler-Fehler

Function body ignored—Compiler-Warnung

Function call missing )—Compiler-Fehler

Function call terminated by unhandled exception 'value' at address 'addr'—Compiler-Fehler

'function' cannot return a value—Compiler-Fehler

Function defined inline after use as extern—Compiler-Fehler

Function definition cannot be a typedef'ed declaration—Compiler-Fehler

Function 'function' cannot be static—Compiler-Fehler

'function' is obsolete—Compiler-Warnung

'function' must be declared with no parameters—Compiler-Fehler

'function' must be declared with one parameter—Compiler-Fehler

'function' must be declared with two parameters—Compiler-Fehler

Function should return a value—Compiler-Fehler

Function should return a value—Compiler-Warnung

'function' was previously declared with the language 'language'—Compiler-Fehler

'function1' cannot be distinguished from 'function2'—Compiler-Fehler

'function1' hides virtual function 'function2'—Compiler-Warnung or error

Functions 'function1' and 'function2' both use same dispatch number—Compiler-Fehler

Functions taking class by value arguments are not expanded inline—Compiler-Warnung

Functions with exception specifications are not expanded inline—Compiler-Warnung

Functions cannot return arrays or functions—Compiler-Fehler

Functions containing local destructors are not expanded inline in function 'function'— Compiler-Warnung

Functions containing reserved words are not expanded inline— Compiler-Warnung

Functions may not be part of a struct or union—Compiler-Fehler

G

General error (32-bit)—Linker-Fehler

General error in library file 'filename' in module 'module' near module file offset '0xyyyyyyyy'—Inkrementelle Linker-Meldung

General error in link set—Inkrementeller Linker-Fehler

General error in module 'module'—Linker-Fehler

General linker message—Inkrementelle Linker-Meldung

Global anonymous union not static—Compiler-Fehler

Goto bypasses initialization of a local variable—Compiler-Fehler

Goto into an exception handler is not allowed—Compiler-Fehler

Goto statement missing label—Compiler-Fehler

Group overflowed maximum size: 'group'—Compiler-Fehler

H

Handler for 'type1' hidden by previous handler for 'type2'—Compiler-Fehler

HEAP commit 'size' greater than reserve 'size'—Linker-Fehler

Hexadecimal value contains more than 3 digits—Compiler-Fehler oder -Warnung

I

'identifier' cannot be declared in an anonymous union—Compiler-Fehler

'identifier' cannot start a parameter declaration—Compiler-Fehler

Identifier expected—Compiler-Fehler

Identifier 'identifier' cannot have a type qualifier—Compiler-Fehler

'identifier' is assigned a value that is never used—Compiler-Fehler oder -Warnung

'identifier' is declared as both external and static—Compiler-Fehler oder -Warnung

'identifier' is declared but never used—Compiler-Warnung

'identifier' is not a member of 'struct'—Compiler-Fehler

'identifier' is not a non-static member and can't be initialized here—Compiler-Fehler

'identifier' is not a parameter—Compiler-Fehler

'identifier' is not a public base class of 'classtype'—Compiler-Fehler

'identifier' must be a member function—Compiler-Fehler

'identifier' must be a member function or have parameter of class type—Compiler-Fehler

'identifier' must be a previously defined class or struct—Compiler-Fehler

'identifier' must be a previously defined enumeration tag—Compiler-Fehler

'identifier' requires VCL style class type—Compiler-Fehler

'identifier' specifies multiple or duplicate access—Compiler-Fehler

If statement missing (—Compiler-Fehler

If statement missing )—Compiler-Fehler

If statement too long—MAKE-Fehler

Ifdef statement too long—MAKE-Fehler

Ifndef statement too long—MAKE-Fehler

Ignored 'module', path is too long—Warnung der Bibliotheksverwaltung

ILINK32 does not support segmentation - use TLINK32—Inkrementeller Linker-Fehler

Ill-formed pragma—Compiler-Warnung

Illegal ACBP byte in SEGDEF in module 'module'—Linker-Fehler

Illegal character 'character' (0x'value')—Compiler-Fehler

lllegal character in constant expression 'expression'—MAKE-Fehler

Illegal component to GRPDEF in module 'module'—Linker-Fehler

Illegal initialization—Compiler-Fehler

Illegal number suffix—Compiler-Fehler

Illegal octal digit—Compiler-Fehler

Illegal octal digit—MAKE-Fehler

Illegal parameter to __emit__—Compiler-Fehler

Illegal pointer subtraction—Compiler-Fehler

Illegal structure operation—Compiler-Fehler

Illegal to take address of bit field—Compiler-Fehler

Illegal type ‘type’ in automated section—Compiler-Fehler

Illegal type of entry point—Linker-Fehler

Illegal 'type' fixup index in module 'module'—Inkrementeller Linker-Fehler

Illegal use of floating point—Compiler-Fehler

Illegal use of member pointer—Compiler-Fehler

Illegal use of pointer—Compiler-Fehler

Illegal/invalid option in CMDSWITCHES directive 'option'—MAKE-Fehler

Image base address must be a multiple of 0x10000—Linker-Fehler

Image linked as EXE, but with DLL extension—Linker-Warnung

Images fixed at specific addresses typically will not run under Win32s—Linker-Warnung

Implicit conversion of 'type1' to 'type2' not allowed—Compiler-Fehler

Import by ordinal not supported by ILINK32—Inkrementeller Linker-Fehler

Import record does not match previous definition—Linker-Warnung

Import 'symbol' in module 'module' clashes with prior module—Fehler der Bibliotheksverwaltung

Improper use of typedef 'identifier'—Compiler-Fehler

Include files nested too deep—Compiler-Fehler

Incompatible type conversion—Compiler-Fehler

Incompatible version of RLINK32.DLL—Inkrementeller Linker-Fehler

Incorrect command line argument: —MAKE-Fehler

Incorrect number format—Compiler-Fehler

Incorrect option—Compiler-Fehler

Incorrect use of default—Compiler-Fehler

Incorrect version of RLINK32.DLL—Linker-Fehler

Initialization is only partially bracketed—Compiler-Warnung

Initializer for object 'x' ignored—Compiler-Warnung

Initializing 'identifier with 'identifier'—Compiler-Fehler

Initializing enumeration with type—Compiler-Warnung

Initializing 'type' with 'type'—Compiler-Warnung

Inline assembly not allowed—Compiler-Fehler

Inline assembly not allowed in inline and template function—Compiler-Fehler

Int and string types compared—MAKE-Fehler

Internal code generator error—Compiler-Fehler

Internal compiler error—Compiler-Fehler

Internal failure -- Retrying link...—Inkrementeller Linker-Fehler

Invalid combination of opcode and operands—Compiler-Fehler

Invalid exe filename: 'filename'—Linker-Fehler

Invalid file/object alignment value 'value'—Linker-Fehler

Invalid indirection—Compiler-Fehler

Invalid macro argument separator—Compiler-Fehler

Invalid map filename: 'filename'—Linker-Fehler

Invalid overlay switch specification—Linker-Fehler

Invalid page size value ignored—Warnung der Bibliotheksverwaltung

Invalid pointer addition—Compiler-Fehler

Invalid register combination (e.g. [BP+BX])—Compiler-Fehler

Invalid size specified for segment alignment—Linker-Fehler

Invalid size specified for segment packing—Linker-Fehler

Invalid stack reserve/commit size 'size'—Linker-Fehler

Invalid target /T 'target'—Linker-Fehler

Invalid template argument list—Compiler-Fehler

Invalid template member definition—Compiler-Fehler

Invalid template qualified name 'template::name'—Compiler-Fehler

Invalid use of dot—Compiler-Fehler

Invalid use of namespace 'identifier'—Compiler-Fehler

Invalid use of template 'template'—Compiler-Fehler

Irreducible expression tree—Compiler-Fehler

L

Last parameter of 'operator' must have type 'int'—Compiler-Fehler

Library contains COMDEF records—extended dictionary not created—Warnung der Bibliotheksverwaltung

Library too large, please restart with /P 'size'—Fehler der Bibliotheksverwaltung

Library too large, restart with library page size 'size'—Fehler der Bibliotheksverwaltung

Linkage specification not allowed—Compiler-Fehler

Linker CREATE Failed—IDE-Fehler

Linker missing CREATE Entry Point—IDE-Fehler

Linker missing DESTROY Entry Point—IDE-Fehler

Link terminated by user—IDE-Fehler

Local data exceeds segment size limit—Compiler-Fehler

Lvalue required—Compiler-Fehler

M

Macro argument syntax error—Compiler-Fehler

Macro definition ignored—Compiler-Warnung

Macro expansion too long—Compiler-Fehler

Macro expansion too long—MAKE-Fehler

Macro replace text 'string' is too long—MAKE-Fehler

Macro substitute text 'string' is too long—MAKE-Fehler

'macroname'—')' missing in macro invocation—MAKE-Fehler

Main must have a return type of int—Compiler-Fehler

Malformed command-line—Linker-Fehler

Malloc of number bytes failed in module, line number—Inkrementeller Linker-Fehler

Matching base class function 'function' has different dispatch number—Compiler-Fehler

Matching base class function 'function' is not dynamic—Compiler-Fehler

Maximum precision used for member pointer type type—Compiler-Fehler

Member function must be called or its address taken—Compiler-Fehler

Member identifier expected—Compiler-Fehler

Member is ambiguous: 'member1' and 'member2'—Compiler-Fehler

'member' is not accessible—Compiler-Fehler

'member' is not a valid template type member—Compiler-Fehler

Member 'member' cannot be used without an object—Compiler-Fehler

Member 'member' has the same name as its class—Compiler-Fehler

Member 'member' is initialized more than once—Compiler-Fehler

Member pointer required on right side of .* or ->*—Compiler-Fehler

Memory full listing truncated!—Warnung der Bibliotheksverwaltung

Memory reference expected—Compiler-Fehler

Misplaced break—Compiler-Fehler

Misplaced continue—Compiler-Fehler

Misplaced decimal point—Compiler-Fehler

Misplaced elif directive—Compiler-Fehler

Misplaced elif statement—MAKE-Fehler

Misplaced else—Compiler-Fehler

Misplaced else statement—MAKE-Fehler

Misplaced else directive—Compiler-Fehler

Misplaced endif directive—Compiler-Fehler

Misplaced endif statement—MAKE-Fehler

'module' already in LIB, not changed!—Warnung der Bibliotheksverwaltung

'module' contains invalid OMF record, type 0xHH—Inkrementeller Linker-Fehler

'module' ILINK32 does not support segmentation - use TLINK32—Inkrementeller Linker-Fehler

'module' not found in library—Warnung der Bibliotheksverwaltung

Mixed common types in module 'module'. Cannot mix COMDEFs and VIRDEFs—Linker-Fehler

Mixing pointers to different 'char' types—Compiler-Fehler

Mixing pointers to signed and unsigned char—Compiler-Warnung

Multiple base classes not supported for VCL classes—Compiler-Fehler

Multiple base classes require explicit class names—Compiler-Fehler

Multiple declaration for 'identifier'—Compiler-Fehler

Multiple entry points defined—Linker-Fehler

Multiple public definitions for symbol 'symbol' in module 'module;' link case sensitively—Linker-Fehler

Multiple stack segments found. The most recent one will be used.—Linker-Warnung

Must take address of a memory location—Compiler-Fehler

N

Namespace member 'identifier' declared outside its namespace—Compiler-Fehler

Namespace name expected—Compiler-Fehler

Need an identifer to declare—Compiler-Fehler

Negating unsigned value—Compiler-Warnung

No : following the ?—Compiler-Fehler

No base class to initialize—Compiler-Fehler

No closing quote—MAKE-Fehler

No declaration for function 'function'—Compiler-Fehler oder -Warnung

No DEF file—Linker-Warnung

No file name ending—Compiler-Fehler

No file names given—Compiler-Fehler

No filename ending—MAKE-Fehler

No internal name for IMPORT in .DEF file—Linker-Fehler

No macro before =—MAKE-Fehler

No match found for wildcard 'expression'—MAKE-Fehler

No output file specified—Linker-Fehler

No program entry point—Linker-Warnung

No terminator specified for in-line file operator—MAKE-Fehler

No type OBJ file present. Disabling external types option—Compiler-Warnung

Non-ANSI Keyword Used: 'keyword'—Compiler-Fehler

Non-const function function called for const object—Compiler-Fehler

Non-constant function 'function' called for constant object—Compiler-Warnung

Non-existent segment 'segment' in SEGMENTS section of .DEF file—Linker-Warnung

Non-virtual function 'function' declared pure—Compiler-Fehler

Non-volatile function 'function' called for volatile object—Compiler-Fehler oder -Warnung

Nonportable pointer comparison—Compiler-Fehler oder -Warnung

Nonportable pointer conversion—Compiler-Fehler

Nonportable pointer conversion—Compiler-Warnung

Nontype template argument must be of scalar type—Compiler-Fehler

Not an allowed type—Compiler-Fehler

Not enough memory—MAKE-Fehler

Not enough memory for command-line buffer—Fehler der Bibliotheksverwaltung

Null pointer assignment—Laufzeitfehler

Numeric constant too large—Compiler-Fehler

O

Object module 'filename' is invalid—Fehler der Bibliotheksverwaltung

Objects of type 'type' cannot be initialized with { }—Compiler-Fehler

Old debug information in module 'module' will be ignored—Linker-Warnung

Only __fastcall functions allowed in __automated section—Compiler-Fehler

Only member functions may be 'const' or 'volatile'—Compiler-Fehler

Only one of a set of overloaded functions can be functions can be "C"—Compiler-Fehler

Only <<KEEP or <<NOKEEP—MAKE-Fehler

Only read or write clause allowed in property declaration in__automated section—Compiler-Fehler

Operand of 'delete' must be non-const pointer—Compiler-Fehler

operator -> must return a pointer or a class—Compiler-Fehler

operator [] missing ]—Compiler-Fehler

operator delete must return void—Compiler-Fehler

Operator delete[] must return void—Compiler-Fehler

Operator must be declared as function—Compiler-Fehler

'operator' must be declared with one or no parameters—Compiler-Fehler

'operator' must be declared with one or two parameters—Compiler-Fehler

Operator new must have an initial parameter of type size_t—Compiler-Fehler

Operator new must return an object of type void *—Compiler-Fehler

Operator new[] must have an initial parameter of type size_t—Compiler-Fehler

Operator new[] must return an object of type void—Compiler-Fehler

Operators may not have default argument values—Compiler-Fehler

Out of disk space—Inkrementeller Linker-Fehler

Out of memory—Compiler-Fehler

Out of memory—Fehler der Bibliotheksverwaltung

Out of memory—Inkrementeller Linker-Fehler

Out of memory creating extended dictionary—Fehler der Bibliotheksverwaltung

Out of memory in block 'address'—Inkrementeller Linker-Fehler

Out of memory reading LE/LIDATA record from object module—Fehler der Bibliotheksverwaltung

Out of space allocating per module debug struct—Fehler der Bibliotheksverwaltung

Output device is full—Fehler der Bibliotheksverwaltung

Overlays only supported in medium, large, and huge memory models—Compiler-Fehler

'overload' is now unnecessary and obsolete—Compiler-Warnung

Overloadable operator expected—Compiler-Fehler

Overloaded 'function name' ambiguous in this context—Compiler-Fehler

Overloaded prefix 'operator' used as a postfix operator—Compiler-Fehler und -Warnung

P

Parameter mismatch in 'specifier' access specifier of property 'property'—Compiler-Fehler

Parameter names are used only with a function body—Compiler-Fehler

Parameter 'number' missing name—Compiler-Fehler

Parameter 'parameter' is never used—Compiler-Fehler und -Warnung

'path'—path is too long—Fehler der Bibliotheksverwaltung

Pointer to structure required on left side of -> or ->*—Compiler-Fehler

Possible unresolved external 'symbol' referenced from module 'module'—Linker-Warnung

Possible use of 'identifier' before definition—Compiler-Fehler und -Warnung

Possibly incorrect assignment—Compiler-Fehler und -Warnung

Printf/Scanf floating point formats not linked—Laufzeitfehler

Public 'symbol' in module 'module1' clashes with prior module 'module2'—Fehler der Bibliotheksverwaltung

Public symbol 'symbol' defined in both module 'module1' and 'module2'—Linker-Meldung

Public symbol 'symbol' defined in both module 'module1' and 'module2'—Inkrementelle Linker-Meldung

__published or__automated sections only supported for VCL classes—Compiler-Fehler

Published property access functions must use __fastcall calling convention—Compiler-Fehler

Pure virtual function called—Laufzeitfehler

Q

Qualifier 'identifier' is not a class or namespace name—Compiler-Fehler

R

Realloc of number bytes failed in module, line number—Inkrementeller Linker-Fehler

'reason'—extended dictionary not created—Warnung der Bibliotheksverwaltung

Record kind 'num' found, expected theadr or lheadr in module 'filename'—Fehler der Bibliotheksverwaltung

Record length 'len' exceeds available buffer in module 'module'—Fehler der Bibliotheksverwaltung

Record type 'type' found, expected theadr or lheadr in module—Fehler der Bibliotheksverwaltung

Recursive template function: '" instantiated ''—Compiler-Fehler

Redeclaration of property not allowed in__automated sedtion'—Compiler-Fehler

Redefinition of 'macro' is not identical—Compiler-Fehler oder -Warnung

Redefinition of target 'filename'—MAKE-Fehler

Reference initialized with 'type1', needs lvalue of type 'type2'—Compiler-Fehler

Reference member 'member' Initialized with a non-reference parameter—Compiler-Fehler

Reference member 'member' in class without constructors—Compiler-Fehler

Reference member 'member' is not initialized—Compiler-Fehler

Reference member 'member' needs a temporary for initialization—Compiler-Fehler

Reference variable 'variable' must be initialized—Compiler-Fehler

Register allocation failure—Compiler-Fehler

Restarting compile using assembly—Compiler-Warnung

Results are safe in file 'filename'—Warnung der Bibliotheksverwaltung

RLINK32 was not initialized—Inkrementeller Linker-Fehler

RTTI not available for expression evaluation—Compiler-Fehler

Rule line too long—MAKE-Fehler

S

Self relative fixupp overflowed in module 'module'—Linker-Warnung

Side effects are not allowed—Compiler-Fehler

Size of 'identifier' is unknown or zero—Compiler-Fehler

Size of the type 'identifier' is unknown or zero—Compiler-Fehler

Size of the type is unknown or zero—Compiler-Fehler

sizeof may not be applied to a bit field—Compiler-Fehler

sizeof may not be applied to a function—Compiler-Fehler

Specialization after first use of template—Compiler-Fehler

'specifier' has already been included—Compiler-Fehler

STACK commit 'size' greater than reserve 'size'—Linker-Fehler

Stack overflow—Laufzeitfehler

Statement missing ;—Compiler-Fehler

Static data members not allowed in __published or __automated sections—Compiler-Fehler

Srorage class 'storage class' is not allowed here—Compiler-Fehler

Srorage specifier not allowed for array properties—Compiler-Fehler

String type not allowed with this operand—MAKE-Fehler

Structure packing size has changed—Compiler-Warnung

Structure passed by value—Compiler-Fehler oder -Warnung

Structure required on left side of . or .*—Compiler-Fehler

Structure size too large—Compiler-Fehler

Style of function definition is now obsolete—Compiler-Fehler oder -Warnung

Subscripting missing ]—Compiler-Fehler

Superfluous & with function—Compiler-Fehler oder -Warnung

Suspicious pointer arithmetic—Compiler-Warnung

Suspicious pointer conversion—Compiler-Fehler oder -Warnung

Switch selection expression must be of integral type—Compiler-Fehler

Switch statement missing (—Compiler-Fehler

Switch statement missing )—Compiler-Fehler

Symbol 'symbol' marked as __import in 'module' was public—Inkrementeller Linker-Fehler

T

T3 and T7 fixupps not allowed (module 'module')—Linker-Fehler

Target index of FIXUPP is 0 in module 'module'—Linker-Fehler

Template argument must be a constant expression—Compiler-Fehler

Template class nesting too deep: 'class'—Compiler-Fehler

Template function argument 'argument' not used in argument types—Compiler-Fehler

Template functions may only have 'type-arguments'—Compiler-Fehler

Templates and overloaded operators cannot have C linkage—Compiler-Fehler

Templates can only be declared at file level—Compiler-Fehler

Templates must be classes or functions—Compiler-Fehler

Templates not supported—Compiler-Fehler

Temporary used for parameter 'parameter'—Compiler-Warnung

Temporary used for parameter 'number'—Compiler-Warnung

Temporary used for parameter 'number' in call to 'function'—Compiler-Warnung

Temporary used for parameter 'parameter'—Compiler-Warnung

Temporary used for parameter 'parameter'—Compiler-Warnung

Temporary used for parameter 'parameter' in call to 'function'—Compiler-Warnung

Temporary used to initialize 'identifier'—Compiler-Fehler oder -Warnung

Terminated by user (32-bit)—Linker-Fehler

The '...' handler must be last—Compiler-Fehler

The combinations '+*' or '*+' are not allowed—Fehler der Bibliotheksverwaltung

The constructor 'constructor' is not allowed—Compiler-Fehler

The value for 'identifier' is not within the range of an int—Compiler-Fehler

'this' can only be used within a member function—Compiler-Fehler

THREAD fixup found in module 'module'—Linker-Fehler

Throw expression violates exception specification—Compiler-Warnung

Too few arguments in template class name 'template'—Compiler-Fehler

Too few parameters in call—Compiler-Fehler

Too few parameters in call to function—Compiler-Fehler

Too many commas on command-line—Linker-Fehler

Too many decimal points—Compiler-Fehler

Too many default cases—Compiler-Fehler

Too many default libraries—Linker-Fehler

Too many error or warning messages—Compiler-Fehler

Too many errors—Linker-Fehler

Too many exponents—Compiler-Fehler

Too many file names—Linker-Fehler

Too many initializers—Compiler-Fehler

Too many LNAMEs—Linker-Fehler

Too many rules for target 'target'—MAKE-Fehler

Too many storage classes in declaration—Compiler-Fehler

Too many suffixes in .SUFFIXES list—MAKE-Fehler

Too many types in declaration—Compiler-Fehler

Too much global data defined in file—Compiler-Fehler

Trying to derive a far class from the huge base 'base'—Compiler-Fehler

Trying to derive a far class from the near base 'base'—Compiler-Fehler

Trying to derive a huge class from the far base 'base'—Compiler-Fehler

Trying to derive a huge class from the near base 'base'—Compiler-Fehler

Trying to derive a near class from the far base 'base'—Compiler-Fehler

Trying to derive a near class from the huge base 'base'—Compiler-Fehler

Two consecutive dots—Compiler-Fehler

Two operands must evaluate to the same type—Compiler-Fehler

'type' is not a polymorphic class type—Compiler-Fehler

Type 'type' is not a defined class with virtual functions—Compiler-Fehler

Type 'typename' may not be defined here—Compiler-Fehler

Type mismatch in default argument value—Compiler-Fehler

Type mismatch in default value for parameter 'parameter'—Compiler-Fehler

Type mismatch in parameter 'number'—Compiler-Fehler

Type mismatch in parameter 'number' in call to 'function'—Compiler-Fehler

Type mismatch in parameter 'number' in template class name 'template'—Compiler-Fehler

Type mismatch in parameter 'parameter'—Compiler-Fehler

Type mismatch in parameter 'parameter' in call to 'function'—Compiler-Fehler

Type mismatch in parameter 'parameter' in template name 'template'—Compiler-Fehler

Type mismatch in redeclaration of 'identifier'—Compiler-Fehler

Type name expected—Compiler-Fehler

U

Unable to create output file 'filename'—Compiler-Fehler

Unable to create turboc.$ln—Compiler-Fehler

Unable to execute command 'command'—Compiler-Fehler

Unable to execute command: 'command'—MAKE-Fehler

Unable to load RW32CORE.DLL—Ressourcen-Compiler-Fehler

Unable to open include file 'filename'—MAKE-Fehler

Unable to open file 'filename'—Linker-Fehler

Unable to open file 'filename'—MAKE-Fehler

Unable to open file 'filename'—Inkrementeller Linker-Fehler

Unable to open 'filename'—Compiler-Fehler

Unable to open 'filename' for output—Fehler der Bibliotheksverwaltung

Unable to open include file 'filename'—Compiler-Fehler

Unable to open input file 'filename'—Compiler-Fehler

Unable to open makefile—MAKE-Fehler

Unable to redirect input or output—MAKE-Fehler

Unable to rename 'filename1' to 'filename2'—Fehler der Bibliotheksverwaltung

#undef directive ignored—Compiler-Warnung

Undefined external type 'data-type'—Inkrementeller Linker-Fehler

Undefined label 'identifier'—Compiler-Fehler

Undefined structure 'structure'—Compiler-Fehler

Undefined structure 'structure'—Compiler-Warnung

Undefined symbol 'identifier'—Compiler-Fehler

Undefined symbol 'symbol' referenced from 'module'—Inkrementeller Linker-Fehler

Unexpected }—Compiler-Fehler

Unexpected char X in command line —Fehler der Bibliotheksverwaltung

Unexpected end of file—MAKE-Fehler

Unexpected end of file in comment started on 'line number'—Compiler-Fehler

Unexpected end of file in conditional started at line 'line number'—MAKE-Fehler

Unexpected end of file in conditional started on 'line number'—Compiler-Fehler

Unexpected termination during compilation [Module Seg#:offset]—Compiler-Fehler

Union cannot be a base type—Compiler-Fehler

Union cannot have a base type—Compiler-Fehler

Union member 'member' is of type class with constructor—Compiler-Fehler

Union member 'member' is of type class with destructor—Compiler-Fehler

Union member 'member' is of type class with operator =—Compiler-Fehler

Unions cannot have virtual member functions—Compiler-Fehler

Unknown assembler instruction—Compiler-Warnung

Unknown CMDSWITCHES operator 'operator'—MAKE-Fehler

Unknown command line switch 'X' ignored—Warnung der Bibliotheksverwaltung

Unknown fatal error—Ressourcen-Compiler-Fehler

Unknown error (# errornum)—IDE-Fehler

Unknown Goodie—Linker-Fehler

Unknown language, must be C or C++—Compiler-Fehler

Unknown option 'option'—Linker-Fehler

Unknown preprocessor directive: 'identifier'—Compiler-Fehler

Unknown preprocessor statement—MAKE-Fehler

Unknown RLINK32 error—Inkrementeller Linker-Fehler

Unreachable code—Compiler-Warnung

Unresolved external 'symbol' referenced from module 'module'—Linker-Fehler

Unsupported 16-bit segment(s) in module 'module'—Inkrementeller Linker-Fehler

Unsupported COMENT OMF extension 'extension'—Linker-Fehler

Unsupported option 'string'—Linker-Fehler

Unterminated string or character constant—Compiler-Fehler

Use '> >' for nested templates instead of '>>'—Compiler-Fehler

Use . or -> to call function—Compiler-Fehler

Use . or -> to call 'member', or & to take its address—Compiler-Fehler

Use /e with TLINK to obtain debug information from library—Warnung der Bibliotheksverwaltung

Use :: to take the address of a member function—Compiler-Fehler

Use of : and :: dependents for target 'target'—MAKE-Fehler

Use qualified name to access member type 'identifier'—Compiler-Warnung

User break—Compiler-Fehler

User break—IDE-Fehler

User break, library aborted—Fehler der Bibliotheksverwaltung

User break. Link aborted—Inkrementeller Linker-Fehler

User-defined message—Compiler-Fehler

Using based linking for DLLs may cause the DLL to malfunction—Linker-Warnung

V

Value of type void is not allowed—Compiler-Fehler

Variable 'identifier' is initialized more than once—Compiler-Fehler

'variable' requires runtime initialization/finalization—Compiler-Fehler

Variable 'variable' has been optimized and is not available—Compiler-Fehler

VCL classes have to be derived from VCL classes —Compiler-Fehler

VCL style class must be constructed using operator new —Compiler-Fehler

VCL style classes must be caught by pointer —Compiler-Fehler

VCL style classes need virtual destructors—Compiler-Fehler

VCL style classes require exception handling to be enabled—Compiler-Fehler

VIRDEF name conflict for 'function'—Compiler-Fehler

Virtual base classes not supported for VCL classes—Compiler-Fehler

'virtual' can only be used with member functions—Compiler-Fehler

Virtual function 'function1' conflicts with base class 'base'—Compiler-Fehler

virtual specified more than once—Compiler-Fehler

void & is not a valid type—Compiler-Fehler

Void functions may not return a value—Compiler-Warnung

W

While statement missing(—Compiler-Fehler

Write error on file 'filename'—MAKE-Fehler

Wrong number of arguments in call of macro 'macro'—Compiler-Fehler


Compiler table limit exceeded
Compiler table limit exceeded	Compiler-Meldung

Eine der internen Tabellen des Compilers ist übergelaufen.

Dies bedeutet in der Regel, daß das compilierte Modul zu viele Funktionsrümpfe enthält.

Diese Beschränkung wird auch dadurch nicht aufgehoben, daß sie dem Compiler mehr Speicher zur Verfügung stellen. Sie sollten die zu compilierende Datei vereinfachen.


Irreducible expression tree
Irreducible expression tree	Compiler-Meldung

Für einen Ausdruck in der angezeigten Zeile der Quelldatei konnte kein Code erzeugt werden. Der Ausdruck sollte vermieden werden. Kontaktieren Sie die Firma Borland, wenn ein Ausdruck beständig diese Meldung erzeugt.


Register allocation failure
Register allocation failure	Compiler-Meldung

Mögliche Ursachen

Ein Ausdruck in der angezeigten Zeile der Quelldatei ist so komplex, daß der Code-Generator dafür keinen Code erstellen konnte.

Lösung

Vereinfachen Sie den Ausdruck. Wenn auch das nicht weiterhilft, vermeiden Sie ihn ganz.

Kontaktieren Sie die Firma Borland, wenn ein Ausdruck beständig diese Meldung erzeugt.


Bad call of intrinsic function
Bad call of intrinsic function	Compiler-Meldung

Sie haben eine Inline-Funktion ohne einen Prototyp aufgerufen, oder der Compiler ist mit dem Prototyp der Inline-Funktion nicht einverstanden.


Unable to open input file 'filename'
Unable to open input file 'filename'	Compiler-Meldung

Diese Meldung bedeutet, daß die Quelldatei nicht gefunden wurde.

Prüfen Sie die Schreibweise des Dateinamens. Stellen Sie sicher, daß sich die Datei auf dem angegebenen Speichermedium und im angegebenen Verzeichnis befindet.

Prüfen Sie, ob die richtigen Verzeichnispfade aufgelistet sind. Wenn mehrere Pfade benötigt werden, dann benutzen Sie ein Semikolon zur Trennung.


Unable to create output file 'filename'
Unable to create output file 'filename'	Compiler-Meldung

Die Diskette/Platte, auf der der Compiler die angegebene Datei erzeugen wollte, ist entweder voll oder schreibgeschützt.

Dieser Fehler tritt auch auf, wenn das Ausgabeverzeichnis nicht existiert.

Lösung

Wenn die Diskette/Platte voll ist, löschen Sie einige nicht benötigte Dateien, und starten Sie den Compiliervorgang erneut.

Ist die Diskette schreibgeschützt, kopieren Sie die Quelldateien auf eine beschreibbare Diskette/Platte, und starten Sie die Compilierung erneut.


Error writing output file
Error writing output file	Compiler-Meldung

Es liegt ein DOS-Fehler vor, der die C++ IDE daran hindert, eine OBJ-, EXE- oder temporäre Datei zu erzeugen.

Lösung

Überprüfen Sie, ob das im Dialogfenster Verzeichnisse gewählte Ausgabeverzeichnis ein gültiges Verzeichnis ist.

Überprüfen Sie, ob Ihre Diskette/Platte über genügend freien Speicherplatz verfügt.


Error directive: 'message'
Error directive: 'message'	Compiler-Meldung

Diese Meldung wird ausgegeben, wenn im Quelltext eine #error-Anweisung bearbeitet wird.

‘message’ ist der Text der #error-Anweisung.


Out of memory (compiler)
Out of memory	Compiler-Meldung

Der Arbeitsspeicher ist komplett belegt.

Dieser Fehler kann aus folgenden Gründen auftreten:

Es ist nicht genügend virtueller Speicher zur Compilierung einer bestimmten Datei verfügbar. Schließen Sie in diesem Fall gegebenenfalls alle anderen laufenden Anwendungen. Sie können des weiteren den virtuellen Speicher neu konfigurieren oder die Quelltextdatei in kleinere Dateien aufspalten. Sie können auch auf einem System compilieren, bei dem mehr RAM verfügbar ist.

Der Compiler ist in der angezeigten Zeile auf einen äußerst komplexen oder langen Ausdruck gestoßen und konnte ihn wegen zu geringer Speicherkapazität nicht zerlegen. Vereinfachen Sie in diesem Fall den Ausdruck oder ersetzen Sie ihn durch mehrere kleinere.


Unable to open 'filename' (compiler)
Unable to open 'filename'	Compiler-Meldung

Die angegebene Datei kann nicht geöffnet werden.

Stellen Sie sicher, daß die Datei sich auf dem angegebenen Laufwerk oder im dem angegebenen Verzeichnis befindet. Verwenden Sie zur Angabe von mehreren Pfaden das Semikolon als Trennzeichen.


Declaration syntax error
Declaration syntax error	Compiler-Meldung

Im Quelltext befindet sich eine Deklaration, die irgendwo ein Zeichen zuviel oder zuwenig hat.

Prüfen Sie, ob sich in dieser oder einer vorhergehenden Zeile z.B. ein fehlendes Semikolon oder eine nicht abgeschlossene Klammerebene befindet.


Wrong number of arguments in call of macro 'macro'
Wrong number of arguments in call of macro 'macro'	Compiler-Meldung

Der Aufruf des benannten Makros erfolgte nicht mit der korrekten Anzahl von Argumenten.


Array size too large
Array size too large	Compiler-Meldung

Das Array belegt mehr als 64 KByte, ohne daß Sie dies mit huge angemeldet haben.

Wenn Sie ein Array dieser Größe brauchen, verwenden Sie entweder den Modifizierer huge wie in diesem Beispiel:

int huge array[70000L];  /* Reserviert 140000 bytes */

oder legen Sie das Array dynamisch an mit farmalloc( ) oder farcalloc( ) z.B.:

int huge *array = (int huge *) farmalloc (sizeof (int) * 70000); ?? Reserviert 140,000 bytes


Invalid macro argument separator
Invalid macro argument separator	Compiler-Meldung

Die Argumente von Makros müssen grundsätzlich durch Kommata voneinander getrennt sein.

Der Compiler hat nach einem Argument ein unzulässiges Zeichen gefunden.

So ist es richtig::

#define tri_add(a, b, c)  ((a) + (b) + (c))

... und so ist es falsch:

#define tri_add(a  b. c)  ((a) + (b) + (c))


Assembler statement too long
Assembler statement too long	Compiler-Meldung

Inline Assembler-Anweisungen dürfen nur bis zu 480 Bytes umfassen.


Macro argument syntax error
Macro argument syntax error	Compiler-Meldung

Ein Makroargument muß immer ein Bezeichner sein.

Der Compiler ist auf ein Zeichen gestoßen, das keinen Bezeichner darstellt.


Bad file name format in include directive/line directive
Bad file name format in include directive	Compiler-Meldung

ODER	Bad file name format in line directive

Dateinamen für #include oder #line müssen entweder mit Anführungszeichen ("FILENAME.H") oder mit spitzen Klammern (<FILENAME.H>) eingefaßt sein.

Dem angegebenen Dateinamen fehlt das erste Anführungszeichen oder die öffnende eckige Klammer.

Bei Verwendung eines Makros fehlen dem Erweiterungstext die umschließenden Anführungszeichen.


Invalid indirection
Invalid indirection	Compiler-Meldung

Der Indirektionsoperator * kann nur zusammen mit nicht als void deklarierten Zeigern verwendet werden.

Beispiel

int main (void)

{

  void *p;

  *p = 10;     /* Fehler: Ungültige Indirektion */

  return 0;

}


Illegal use of pointer
Illegal use of pointer	Compiler-Meldung

Zeiger sind nur im Zusammenhang mit folgenden Operatoren erlaubt:

Addition(+)

Subtraktion(-)

Zuweisung(=)

Vergleich(==)

Indirektion(*)

Pfeil(->)

Ihre Quelldatei benutzte einen Zeiger mit einem anderen Operator..

Beispiel

int main (void)

{

  char *p;

  p /= 7;     /* Fehler: Ungültige Verwendung eines Zeigers */

  return 0;

}


Not an allowed type
Not an allowed type	Compiler-Meldung

Sie haben einen Typ deklariert, der in C nicht erlaubt ist, beispielsweise eine Funktion, die eine Funktion oder ein Array zurückliefert.


Incompatible type conversion
Incompatible type conversion	Compiler-Meldung

Die Typumwandlung konnte nicht ausgeführt werden.


Misplaced decimal point
Misplaced decimal point	Compiler-Meldung

Ein Dezimalpunkt ist im Exponenten von Fließkommazahlen nicht zugelassen.


Incorrect use of default
Incorrect use of default	Compiler-Meldung

Der Compiler hat keinen Doppelpunkt nach dem voreingestellten Schlüsselwort gefunden.


Invalid use of dot
Invalid use of dot	Compiler-Meldung

Auf den Operator Punkt (.) muß unmittelbar der Bezeichner folgen.

Beispiel

struct foo {

  int x;

  int y;

}p = 0,0;

int main (void)

{

  p.x++;         /* Richtig */

  p.  y++;       /* Fehler: Ungültige Verwendung des Punktes */

  return 0;

}


Function call missing )
Function call missing )	Compiler-Meldung

Die Parameterliste des Funktionsaufrufes weist einen Syntaxfehler auf, z.B. eine fehlende oder falsch gesetzte rechte Klammer.


Case statement missing :
Case statement missing :	Compiler-Meldung

Eine case-Anweisung muß einen Konstantenausdruck gefolgt von einem Doppelpunkt haben.

Dem Ausdruck in der case-Answeisung fehlte entweder der Doppelpunkt, oder vor dem Doppelpunkt befand sich ein überzähliges Sonderzeichen.


Character constant must be one or two characters long
Character constant must be one or two characters long	Compiler-Meldung

char-Konstanten dürfen maximal 1 oder 2 Zeichen umfassen.


Compound statement missing }
Compound statement missing }	Compiler-Meldung

Der Compiler hat das Ende der Quelldatei erreicht und noch kein abschließendes } gefunden.

Vermutlich haben Sie irgendwo eine falsche Klammer gesetzt.


Cannot modify a const object
Cannot modify a const object	Compiler-Meldung

Dieser Fehler weist auf eine unzulässige Operation auf einem als const deklarierten Objekt hin. Ein Beispiel dafür wäre eine Zuweisung an ein Objekt.


Declaration missing ;
Declaration missing ;	Compiler-Meldung

In einer Deklaration eines struct- oder union-Feldes fehlt das abschließende Semikolon.

Untersuchen Sie die vorhergehenden Zeilen auf ein fehlendes Semikolon.


Define directive needs an identifier
Define directive needs an identifier	Compiler-Meldung

Das erste Zeichen nach #define und den Leerzeichen muß ein Bezeichner sein.

Der Compiler hat irgendein anderes Zeichen gefunden.


Too much global data defined in file
Too much global data defined in file	Compiler-Meldung

Mehr als 64 KByte globaler Variablen sind in einem Modul nicht erlaubt. Dies bezieht sich auf alle in der DGROUP gespeicherten Daten (alle globalen Variablen, literalen Strings und statische Lokale).

Lösung

Prüfen Sie, ob sich Arrays verkleinern lassen. Entfernen Sie gegebenenfalls Variablen aus der DGROUP:

Gehen Sie dazu folgendermaßen vor:

 	Deklarieren Sie die Variablen als automatisch. Dadurch machen Sie Gebrauch vom Stack.

 	Reservieren Sie für die Variablen dynamischen Speicher aus dem Heap mit Hilfe der Funktionen calloc, malloc oder farmalloc. Dabei müssen Sie Zeiger verwenden.

Literale werden auch in der DGROUP abgelegt. Besorgen Sie sich die Datei FARSTR.ZIP von unserem

BBS, um Literal-Strings in ihrem eigenen Segment abzulegen.


Two consecutive dots
Two consecutive dots	Compiler-Meldung

Eine variable Anzahl von Parametern wird mit drei Punkten (...) deklariert, für die Adressierung von Strukturen und innerhalb von Fließkommazahlen wird ein Punkt verwendet. Zwei aufeinanderfolgende Punkte sind kein zulässiges C-Konstrukt.


Too many storage classes in declaration
Too many storage classes in declaration	Compiler-Meldung

Eine Deklaration kann nur eine der Speicherklassen Auto, Register, Static oder Extern enthalten.


Too many types in declaration
Too many types in declaration	Compiler-Meldung

Eine Deklaration kann nur jeweils einen der folgenden Grundtypen enthalten:

 	char

 	class

 	int

 	float

 	double

 	struct

 	union

 	enum

 	typedef Name


Misplaced elif directive
Misplaced elif directive	Compiler-Meldung

Der Compiler ist auf eine #elif-Anweisung ohne vorhergehende #if-, #ifdef- oder #ifndef-Anweisung gestoßen.


Misplaced else directive
Misplaced else directive	Compiler message

Der Compiler ist auf eine #else-Anweisung ohne zugehörige #if-, #ifdef- oder #ifndef-Anweisung gestoßen.


Misplaced endif directive
Misplaced endif directive	Compiler-Meldung

Der ist auf eine ungültige  #endif- Anweisung ohne zugehörige #if-, #ifdef- oder #ifndef-Anweisung gestoßen.


Enum syntax error
Enum syntax error	Compiler-Meldung

Eine enum-Anweisung wurde ohne gültige Bezeichnerliste vorgefunden.


Unexpected end of file in comment started on 'line number'
Unexpected end of file in comment started on 'line number'	Compiler-Meldung

Die Quelldatei endet inmitten eines Kommentars.

Hier fehlt normalerweise irgendwo der Abschluß des Kommentars mit */.


Unexpected end of file in conditional started on 'line number'
Unexpected end of file in conditional started on 'line number'	Compiler-Meldung

Die Quelldatei endete, bevor der Compiler (oder MAKE) auf ein erwartetes #endif gestoßen ist.

Das #endif fehlte entweder ganz oder war falsch geschrieben.

Jede #if-Anweisung muß mit einer #endif-Anweisung abgeschlossen werden.


Expression syntax
Expression syntax	Compiler-Meldung

Dies ist eine allgemeine Fehlermeldung, wenn der Compiler einen Ausdruck nicht auswerten kann.

Mögliche Ursachen

Dies wird überwiegend von einem der folgenden Fälle verursacht:

 	Zwei aufeinanderfolgende Operatoren.

 	Nicht übereinstimmende oder fehlende Klammern.

 	Ein fehlendes Semikolon in der vorhergehenden Anweisung.

Lösung

Wenn die betreffende Zeile syntaktisch korrekt ist, überprüfen Sie die unmittelbar vorhergehende Zeile.

Kopieren Sie die fehlerhafte Anweisung an eine andere Stelle der Datei und compilieren Sie diese erneut.

Taucht der alte Fehler jetzt an der neuen Stelle auf, liegt er mit Sicherheit innerhalb der kopierten Anweisung.

Andernfalls liegt er vermutlich in unmittelbarer Umgebung der beanstandeten Anweisung.


Too few parameters in call
Too few parameters in call	Compiler-Meldung

Ein Funktionsaufruf mit Prototyp (via Funktionszeiger) erfolgte mit zu wenig Parametern. Prototypen erfordern die Übergabe aller Parameter. Stellen Sie sicher, daß der Aufruf Ihrer Funktion die gleichen Parameter wie der Funktionsprototyp enthält.


Too few parameters in call to 'function'
Too few parameters in call to 'function'	Compiler-Meldung

Eine zuvor mit einem Prototypen deklarierte Funktion wurde mit zu wenig Parametern aufgerufen.

Stellen Sie sicher, daß die Parameter des Funktionsaufrufs mit den Parametern des Funktionsprototyps übereinstimmen.


Illegal use of floating point
Illegal use of floating point	Compiler-Meldung

Fließkommazahlen dürfen mit den folgenden Operatoren nicht verwendet werden.

 	Schiebefehl (SHL, SHR).

 	Bitweise Boolesch (AND, OR, XOR, NOT).

 	Bedingt (? :).

 	Indirektion (*).

 	Bestimmte andere Operatoren.

Der Compiler hat eine Fließkommazahl in Verbindung mit einem der obigen, nicht erlaubten Operatoren gefunden.


File name too long
File name too long	Compiler-Meldung

Der in einer #include-Anweisung angegebene Dateiname war zu lang. Der Compiler konnte ihn deshalb nicht verarbeiten.

Dateinamen dürfen unter DOS nur bis zu 79 Zeichen lang sein.


Conflicting type modifiers
Conflicting type modifiers	Compiler-Meldung

Dieser Fall tritt ein, wenn eine Zeigerdeklaration mehr als einen Adreßmodifizierer oder eine Funktionsdeklaration mehr als einen Sprachmodifizierer hat.

Einer Funktion kann nur ein Sprachmodifizierer (cdecl und pascal) zugeordnet werden.

Man kann nicht von mehreren Klassen ableiten, von denen eine die schnelle this-Zeigeroptimierung benutzt, eine andere hingegen nicht. Zum Beispiel:

class __fastthis A { // Eine Möglichkeit, this-Optimierung zu

   myex();           // deklarieren. Beachten Sie, daß die #pragma-.

};                   // Beachten Sie, daß die #pragma-Option -po- die Optimierung ausschaltet.

class B {

   twoex();

};

class c : A , B {}; // Fehler

// //__fastthis wird nur von BC 4.0 oder höher erkannt


Goto statement missing label
Goto statement missing label	Compiler-Meldung

Auf das reservierte Wort goto muß ein Bezeichner folgen.


Group overflowed maximum size: 'name'
Group overflowed maximum size: 'name'	Compiler-Meldung

Die Gesamtgröße der Segmente einer Gruppe (z.B. DGROUP) überstieg 64KB.


Illegal character 'character' (0x'value')
Illegal character 'character' (0x'value')	Compiler-Meldung

Der Compiler hat in der Eingabedatei ein unzulässiges Zeichen gefunden.

Der hexadezimale Wert des Zeichens wird ausgegeben.

Dieser Fehler kann auch durch die Übergabe eines zusätzlichen Parameters an ein Funktionsmakro ausgelöst werden.


Illegal initialization
Illegal initialization	Compiler-Meldung

Initialisierungen müssen auf eine der folgenden Weisen vorgenommen werden:

Mit konstanten Ausdrücken.

Mit der Adresse einer globalen Variablen, extern oder static, mit einer Konstanten mehr oder weniger.


Unable to open include file 'filename'
Unable to open include file 'filename'	Compiler-Meldung

Der Compiler konnte die angegebene Datei nicht finden.

Mögliche Ursachen

Die genannte Datei existiert nicht.

 	Eine #include-Datei enthält eine #include-Direktive für sich selbst.

 	Sie haben den Parameter FILES in der Datei CONFIG.SYS Ihres Stammverzeichnisses nicht groß genug gewählt.

Lösung

Prüfen Sie, ob die genannte Datei vorhanden ist.

 	Setzen Sie in der Datei CONFIG.SYS den Parameter FILES = 20.


No file name ending
No file name ending	Compiler-Meldung

Ein Dateiname in einer #include -Anweisung ist nicht dem richtigen Anführungszeichen oder einer spitzen Klammer abgeschlossen worden.


Lvalue required
Lvalue required	Compiler-Meldung

Auf der linken Seite einer Zuweisung muß ein L-Wert stehen, d.h. ein Ausdruck, dem etwas zugeordnet werden kann.

L-Werte können sein:

 	Numerische Variablen und Zeigervariablen.

 	Strukturkomponenten oder Indirektionen durch Zeiger.

 	Indizierte Array-Elemente.


Too many error or warning messages (compiler)
Too many error or warning messages	Compiler-Meldung

Mehr Fehlermeldungen oder Warnungen als erlaubt sind aufgetreten.


statement missing (
statement missing (	Compiler-Meldung

In einer do-, for-, if-, switch- oder while-Anweisung hat der Compiler nach dem reservierten Wort while oder dem Bedingungsausdruck keine geöffnete Klammer gefunden.


statement missing )
statement missing )	Compiler-Meldung

In einer do-, for-, if-, switch- oder while-Anweisung hat der Compiler nach dem reservierten Wort while oder dem Bedingungsausdruck keine geschlossene Klammer gefunden.


do-while statement missing ; OR For statement missing ;
do-while statement missing ODER For statement missing ;	Compiler-Meldung

In einer do- oder for-Anweisung fehlt das Semikolon hinter der abschließenden Klammer.


Type mismatch in redeclaration of 'identifier'
Type mismatch in redeclaration of 'identifier'	Compiler-Meldung

Eine Variable in ihrer Quelldatei hat einen anderen Typ als ursprünglich vereinbart.

Mögliche Ursachen

Der Compiler nimmt bei jeder noch nicht deklarierten Funktion den Ergebnistyp int an. Wenn Sie diese Funktion zu einem späteren Zeitpunkt mit einem anderen Ergebnistyp definieren, ergibt sich diese Fehlermeldung.

Lösung

Deklarieren Sie den Prototypen der Funktion, bevor Sie sie zum ersten Mal aufrufen.


Default outside of switch
Default outside of switch	Compiler-Meldung

Eine default-Anweisung ist nur innerhalb einer switch-Anweisung erlaubt.

Hier handelt es sich meistens um eine falsch plazierte geschweifte Klammer.


Macro expansion too long
Macro expansion too long	Compiler-Meldung

Eine Makro-Erweiterung darf nicht mehr als 4096 Zeichen umfassen.


Too many decimal points
Too many decimal points	Compiler-Meldung

Der Compiler hat eine Fließkommazahl mit mehr als einem Dezimalpunkt gefunden.


Too many exponents
Too many exponents	Compiler-Meldung

Der Compiler hat mehr als eine Exponentenangabe in einer Fließkommazahl gefunden.


Too many initializers
Too many initializers	Compiler-Meldung

Es sind mehr Initialisierungswerte angegeben, als für diese Variable in der Deklaration definiert wurden.


Inline assembly not allowed
Inline assembly not allowed	Compiler-Meldung

Die Compilierung von Programmen mit Inline-Anweisungen im Assembler Code ist innerhalb der integrierten Entwicklungsumgebung nicht möglich.

Sie müssen in der DOS-Kommandozeile den Befehl BCC verwenden, um diese Quelldatei zu kompilieren.


Incorrect number format
Incorrect number format	Compiler-Meldung

Hexadezimalzahlen dürfen keinen Dezimalpunkt enthalten.


Numeric constant too large
Numeric constant too large	Compiler-Meldung

Es können keine String- oder Zeichen-Escape-Sequenzen erzeugt werden, die hexadezimal oder oktal größer als 77 sind.

Zwei-Byte-Zeichenkonstanten können mit Hilfe eines zweiten Backslash angegeben werden. Zum Beispiel steht

\\

für eine Zwei-Byte-Konstante.

Ein numerisches Literal direkt nach einer Escape-Sequenz sollte so abgetrennt werden:

printf("\x0D" "12345");

Damit werden ein Zeilenvorschub und danach 12345 ausgegeben.


Illegal octal digit
Illegal octal digit	Compiler-Meldung

In oktalen Konstanten sind nur 0..7 als Ziffern erlaubt.


Type mismatch in parameter 'number' in call to 'function'
Type mismatch in parameter 'number' in call to 'function'	Compiler-Meldung

In Ihrer Quelldatei ist die genannte Funktion mit einem Prototypen deklariert worden, und die angegebene Parameternummer (ab 1 von links nach rechts gezählt) konnte nicht in den deklarierten Parametertyp umgewandelt werden.

Bei der Compilierung von C++ Programmen geht dieser Meldung immer eine andere Meldung voraus, die die genaue Ursache für den Typkonflikt nennt.

Diese andere Meldung lautet zumeist "Cannot convert 'type1' to 'type2'" (kann Typ1 nicht in Typ2 umwandeln), aber der Konflikt kann auch viele andere Ursachen haben.


Type mismatch in parameter 'parameter' in call to 'function'
Type mismatch in parameter 'parameter' in call to 'function'	Compiler-Meldung

Sie haben die genannte Funktion über einen Prototypen deklariert. Der angegebene Parameter konnte nicht in den deklarierten Parametertypen konvertiert werden.

In C++ erhalten Sie zu dieser Meldung eine weitere, die Ihnen das Problem genauer erklärt.

Diese lautet dann gewöhnlich "Cannot convert 'type1' to 'type2'" ("kann Typ1 nicht in Typ2 umwandeln"), doch die Ursachen für die Nichtübereinstimmung können vielfältig sein.


Type mismatch in parameter 'number'
Type mismatch in parameter 'number'	Compiler-Meldung

Sie haben die genannte Funktion über einen Prototypen als Funktionszeiger deklariert.

Die bezeichnete Parameter-Nummer (beginnend von links mit 1) konnte nicht in den deklarierten Parametertypen konvertiert werden.

In C++ erhalten Sie zu dieser Meldung eine weitere, die Ihnen das Problem genauer erklärt.

Diese lautet dann gewöhnlich "Cannot convert 'type1' to 'type2'" ("kann Typ1 nicht in Typ2 umwandeln"), doch die Ursachen für die Nichtübereinstimmung können vielfältig sein.


Type mismatch in parameter 'parameter'
Type mismatch in parameter 'parameter'	Compiler-Meldung

Die über einen Zeiger aufgerufene Funktion wurde über einen Prototypen als Funktionszeiger deklariert.

Der mit Parameter bezeichnete Parameter konnte nicht in den deklarierten Parametertypen konvertiert

werden.

In C++ erhalten Sie zu dieser Meldung eine weitere, die Ihnen das Problem genauer erklärt.

Diese lautet dann gewöhnlich "Cannot convert 'type1' to 'type2'" ("kann Typ1 nicht in Typ2 umwandeln"), doch die Ursachen für die Nichtübereinstimmung können vielfältig sein.


Pointer to structure required on left side of -> or ->*
Pointer to structure required on left side of -> or ->*	Compiler-Meldung

Auf der linken Seite des Pfeiles (->) ist in C oder C++ nur die Angabe von Zeigern zugelassen.

In C++ ist der Operator -> erlaubt.


Invalid pointer addition
Invalid pointer addition	Compiler-Meldung

Zu einem Zeiger kann kein anderer Zeiger hinzuaddiert werden.


Illegal pointer subtraction
Illegal pointer subtraction	Compiler-Meldung

Sie haben versucht, einen Zeiger von einem Nicht-Zeiger zu subtrahieren.


Illegal structure operation
Illegal structure operation	Compiler-Meldung

Strukturen können nur zusammen mit dem Punktoperator (.), dem Adreßoperator (&), dem Zuweisungsoperator (=) oder als Funktionsparameter verwendet werden.

Der Compiler entdeckte eine Struktur, die mit einem anderen Operator verwendet wurde.


Bad define directive syntax
Bad 'directive' directive syntax	Compiler-Meldung

Eine Makrodefinition beginnt oder endet mit dem Operator ## oder sie enthält den Operator # ohne einen folgenden für ein Makroargument.

Eine Beispiel dafür könnte sein:

Bad ifdef directive syntax

Beachten Sie, daß eine #ifdef-Anweisung als Anweisungsblock nur einen Bezeichner (und sonst nichts)

enthalten darf.

Ein weiteres Beispiel ist:

Bad undef directive syntax

Auch eine #undef-Anweisung darf als Anweisungsblock nur einen Bezeichner enthalten.


Unterminated string or character constant
Unterminated string or character constant	Compiler-Meldung

Eine Zeichen- oder String-Konstante wurde nicht durch Anführungszeichen abgeschlossen.


Structure size too large
Structure size too large	Compiler-Meldung

Eine Struktur darf nicht größer als 64 KByte sein.


Unknown preprocessor directive: 'identifier'
Unknown preprocessor directive: 'identifier'	Compiler-Meldung

Der Quelltext enthält eine Zeile, die mit einem # beginnt, darauf folgt aber keiner der folgenden Befehle:

 	define

 	else

 	endif

 	if

 	ifdef

 	ifndef

 	include

 	line

 	undef


Undefined symbol 'identifier'
Undefined symbol 'identifier'	Compiler-Meldung

Der genannte Bezeichner wurde nicht deklariert.

Mögliche Ursachen

Die tatsächliche Deklaration des Bezeichners ist als Kommentar gekennzeichnet.

Ein Tippfehler beim Zugriff oder bei der Deklaration.

Eine fehlerhafte Deklaration.

Folgende Hilfsprogramme können bei der Fehlersuche eingesetzt werden:

CPP

GREP


Could not find file 'filename'
Could not find file 'filename'	Compiler-Meldung

Der als Kommandozeilenparameter übergebene Dateiname ist ungültig, oder die entsprechende Datei läßt sich nicht lokalisieren.


Nonportable pointer conversion (error)
Non-portable pointer conversion	Compiler-Warnung

 (Der entsprechende Kommandozeilenschalter zur Anzeigensteuerung lautet -wrpt)

Es wird hier eine implizite Umwandlung von einem Zeiger in einen ganzzahligen Wert verlangt, die Typen haben aber nicht dieselbe Größe. Hier ist eine explizite Umwandlung erforderlich.

Die Umwandlung ist eventuell nicht sinnvoll, überprüfen Sie Ihren Code daher noch einmal.


Extra parameter in call
Extra parameter in call	Compiler-Meldung

Der Aufruf einer Funktion, die über einen Zeiger auf einen Prototypen deklariert wurde, erfolgte mit zu vielen Parametern.


Extra parameter in call to function
Extra parameter in call to function	Compiler-Meldung

Der Aufruf einer Funktion, die bereits über einen Prototypen deklariert wurde, erfolgte mit zu vielen Parametern.


User break (compiler)
User break	Compiler-Meldung

Sie haben die Compilierung durch Eingabe von Strg+Untbr abgebrochen.

(Dies ist nur eine Bestätigung, keine Fehlermeldung)


Multiple base classes require explicit class names
Multiple base classes require explicit class names	Compiler-Meldung

In einem Klassenkonstruktor von C++ muß jeder Aufruf des Klassenkonstruktors der Basisklasse im Konstruktorkopf den Namen der Basisklasse enthalten, wenn mehr als eine unmittelbare Basisklasse existieren.


Member is ambiguous: 'member1' and 'member2'
Member is ambiguous: 'member1' and 'member2'	Compiler-Meldung

Die Bezugnahme auf ein Element muß mit dem Namen der entsprechenden Basisklasse einhergehen.

In C++ gehören die Klasse Klasse und das Element Element zu mehr als einer Basisklasse, und es ist unklar, welche Sie meinen.

Dies trifft nur bei mehrfacher Vererbung zu, wenn ein Elementname in jeder Basisklasse nicht durch denselben Namen in einer abgeleiteten Klasse desselben Pfades verdeckt wird.

Die Sprachregeln von C++ verlangen, daß diese Zweideutigkeitsprüfung vor der Überprüfung der Zugriffsrechte (private, protected, public) vorgenommen wird.

Sie können diese Meldung selbst dann erhalten, wenn ohnehin nur auf eins (oder keines) der Elemente zugegriffen werden kann.


'function1' cannot be distinguished from 'function2'
'function1' cannot be distinguished from 'function2'	Compiler-Meldung

Die Parameterlisten in den Deklarationen dieser Funktionen sind sich zu ähnlich, um klar unterschieden werden zu können.

Ändern Sie die Reihenfolge oder den Typ eines Parameters einer Deklaration.


Attempt to grant or reduce access to 'identifier'
Attempt to grant or reduce access to 'identifier'	Compiler-Meldung

In C++ kann eine abgeleitete Klasse die Zugriffsrechte eines Basisklassenelements abändern, aber nur, um sie nachher wieder herzustellen.

Es können keine Rechte hinzugefügt oder weggenommen werden.


Array must have at least one element
Array must have at least one element	Compiler-Meldung

ANSI C und C++ schreiben vor, daß ein Array mindestens ein Element enthalten muß, da Objekte der Größe Null nicht erlaubt sind.

Ein alter Programmiertrick sieht als Element einer Struktur ein Array der Größe Null vor und liefert später den nötigen Speicherplatz mit malloc.

Um diesen Trick nach wie vor anzuwenden, müssen Sie mindestens ein Element für das Array vorsehen, wenn Sie im ANSI-Standard compilieren.

Im Gegensatz zu Definitionen sind nach wie vor Deklarationen von Arrays unbekannter Größe möglich.

Beispiel

char ray[];         /* Definition unbekannter Größe - NICHT ERLAUBT */

char ray[0];        /* Definition der Größe Null - NICHT ERLAUBT */

extern char ray[];  /* Deklaration unbekannter Größe - ERLAUBT */


operator -> must return a pointer or a class
operator -> must return a pointer or a class	Compiler-Meldung

Die C++ Operatorfunktion -> muß als Ergebnis entweder eine Klasse oder einen Zeiger auf eine Klasse (oder struct oder union) liefern.

In jedem Fall muß sich der Pfeiloperator (->) auf etwas beziehen können.


'identifier' must be a previously defined class or struct
'identifier' must be a previously defined class or struct	Compiler-Meldung

Sie versuchen, Bezeichner als Basisklasse zu definieren, doch entweder ist er keine Klasse oder nicht vollständig definiert.

Ändern Sie den Namen oder die Deklarationen.


Misplaced break
Misplaced break	Compiler-Meldung

Eine break -Anweisung wurde außerhalb einer Schleife oder eines switch- oder Schleifenkonstruktes gefunden.

break-Anweisungen sind nur innerhalb von switch-Anweisungen oder Schleifen erlaubt.


Switch selection expression must be of integral type
Switch selection expression must be of integral type	Compiler-Meldung

Der Auswahlausdruck in den Klammern einer switch-Anweisung muß ganzzahlig sein (char, short, int, long, enum).

Vielleicht ist dies mit einer expliziten Typumwandlung zu erreichen.


Cannot cast from 'type1' to 'type2'
Cannot cast from 'type1' to 'type2'	Compiler-Meldung

Eine Typumwandlung von Typ1 nach Typ2 ist nicht zulässig.

Sie können in C++ einen Zeiger auf eine Elementfunktion nicht in einen Zeiger auf eine normale Funktion umwandeln.

Zum Beispiel:

class A {

public:

   int myex();

};

typedef int (*fp)();

test()

{

   fp myfp - (fp) &A::myex; // Fehler

Eine Elementfunktion führt einen versteckten Parameter mit sich, den this-Zeiger, der sich anders als ein normaler Funktionszeiger verhält.

Eine statische Elementfunktion (d.h. diese Funktion besitzt keinen this-Zeiger) verhält sich wie eine normale Funktion, eine Umwandlung kann stattfinden.

Zum Beispiel:

class A {

public:

   static int myex();

};

typedef int (*fp)();

test()

{

   fp myfp - (fp) &A::myex; //ok

Jedoch können statische Elementfunktionen auch nur auf statische Datenelemente der Klasse zugreifen.

In C

 	Ein Zeiger kann in einen anderen Zeiger oder einen Integer-Wert umgewandelt werden.

 	Ein Integer kann in jeden Integer-, Fließkomma- oder Zeigertypen umgewandelt werden.

 	Ein Fließkommatyp kann in einen Fließkomma- oder einen Integertypen umgewandelt werden.

Strukturen und Arrays können nicht ineinander umgewandelt werden.

Der Datentyp void kann normalerweise auch nicht umgewandelt werden.

In C++

In C++ werden vom Anwender definierte Umwandlungsvorschriften und Konstruktoren überprüft. Falls keine vorkommen, gelten die oben genannten Regeln, außer für Zeiger auf Klassenelemente.

Bei Integer-Werten darf nur die Konstante Null in den Zeiger auf ein Element umgewandelt werden.

Ein Elementzeiger kann in einen Integertyp oder in einen ähnlichen Elementzeiger umgewandelt werden.

Ein ähnlicher Zeiger bedeutet Zeiger auf ein Datenelement (oder eine Funktion), falls der ursprüngliche Zeiger dorthin zeigt. Die qualifizierende Klasse des unzuwandelnden Typs muß die gleiche Klasse, wie die ursprüngliche Klasse, oder eine Basisklasse von ihr sein.


Constructor cannot have a return type specification
Constructor cannot have a return type specification	Compiler-Meldung

In C++ haben Konstruktoren einen impliziten Rückgabetyp, der vom Compiler benutzt wird. Sie selbst dürfen aber explizit weder einen Rückgabetypen noch einen Rückgabewert deklarieren.


Misplaced continue
Misplaced continue	Compiler-Meldung

continue-Anweisungen sind außerhalb von Schleifen nicht erlaubt.


Declaration terminated incorrectly
Declaration terminated incorrectly	Compiler-Meldung

Nach der Deklaration steht ein zusätzliches oder falsches Zeichen, z.B. ein Semikolon nach einem Funktionsrumpf.

Bei einer C++ Elementfunktion, die in einer Klasse zwischen Kopf und der ersten linken Klammer deklariert wird, taucht dieser Fehler ebenfalls auf.


Need an identifier to declare
Need an identifier to declare	Compiler-Meldung

In diesem Zusammenhang wird ein Bezeichner erwartet, um die Deklaration zu vervollständigen.

Es kann z.B. ein typedef ohne Namen oder ein zusätzlicher Strichpunkt auf Dateiebene vorliegen.

In C++ kann das ein Klassenname sein, der fälschlich für eine andere Bezeichnerart verwendet wird.


Default value missing
Default value missing	Compiler-Meldung

Deklariert eine C++ Funktion einen Parameter mit Vorgabewert, müssen alle folgenden Parameter auch einen Vorgabewert haben.

In dieser Deklaration war dies nicht der Fall.


Declare operator delete (void*) or (void*, size_t)

Declare operator delete[] (void*) or (void*, size_t)	Compiler-Meldung

Korrekt deklarieren Sie den Operator delete auf eine der beiden folgenden Weisen:

1.	Mit einem einzelnen void*-Parameter.

2.	Einem zweiten Parameter des Typs size_t.

Die zweite Version ist der ersten vorzuziehen.

Der globale Operator delete kann nur mit einem einzelnen Parameter deklariert werden.


operator delete must return void

operator delete[] must return void	Compiler-Meldung

Der überladene C++ Operator delete muß void zurückliefern. Er war hier anders deklariert.

Korrekt deklarieren Sie den Operator delete auf eine der beiden folgenden Weisen:

1.	Mit einem einzelnen void*-Parameter.

2.	Einem zweiten Parameter des Typs size_t.

Die zweite Version ist der ersten vorzuziehen.

Der globale Operator delete kann nur mit einem einzelnen Parameter deklariert werden.


Destructor name must match the class name
Destructor name must match the class name	Compiler-Meldung

In einer C++ Klasse steht die Tilde (~) vor der Deklaration des Klassendestruktors.

Dieser muß genauso heißen wie die Klasse.

Hier steht die Tilde vor einem anderen Namen.


Destructor cannot have a return type specification
Destructor cannot have a return type specification	Compiler-Meldung

C++ Destruktoren können niemals einen Wert zurückliefern, und der Typ des Rückgabewerts kann nicht deklariert werden.


Default value missing following parameter 'parameter'
Default value missing following parameter 'parameter'	Compiler-Meldung

Deklariert eine C++ Funktion einen Parameter mit Vorgabewert, müssen alle folgenden Parameter auch einen solchen haben.


Misplaced else
Misplaced else	Compiler-Meldung

Dem Compiler fehlt bei einer else-Anweisung ein vorangehendes if..

Mögliche Ursachen

 	Eine überzählige else-Anweisung.

 	Ein überzähliges Semikolon.

 	Fehlende Klammern.

 	Ein Syntaxfehler in einer vorangegangenen if-Anweisung.


Unknown language, must be C or C++
Unknown language, must be C or C++	Compiler-Meldung

Im C++ Konstrukt

extern "name" type func( /*...*/ );

muß der angegebene "Name" der Sprache C oder C++ entstammen (verwenden Sie die Anführungszeichen), andere Sprachen werden nicht akzeptiert.

Eine externe Pascal-Funktion kann folgendermaßen deklariert werden, ohne daß der Compiler sie umbenennt:

extern "C" int pascal func( /*...*/ );

Eine (möglicherweise überladene) C++ Funktion können Sie folgendermaßen als Pascal deklarieren und zugleich das Umbenennen durch den Compiler zulassen (um das Überladen zu erlauben):

extern int pascal func( /*...*/ );


'function' was previously declared with the language 'language'
'function' was previously declared with the language 'language'	Compiler-Meldung

Einer Funktion kann nur ein Sprachmodifizierer(cdecl pascal) zugeordnet werden.

Der Funktion wurden an zwei Stellen verschiedene Sprachmodifizierer zugeordnet.


Parameter names are used only with a function body
Parameter names are used only with a function body	Compiler-Meldung

Bei der Deklaration einer Funktion ohne Funktionsrumpf müssen entweder leere Klammern oder ein Funktionsprototyp angegeben werden.

Eine Liste nur mit Parameternamen ist nicht erlaubt.

Deklarationsbeispiele:

int func();             /* Deklaration ohne Prototyp - ZULÄSSIG */

int func(int, int);     /* Deklaration mit Prototyp - ZULÄSSIG */

int func(int i, int j); /* Parameternamen im Prototyp - ZULÄSSIG */

int func(i, j);         /* Parameternamen allein - NICHT ZULÄSSIG */


Extern variable cannot be initialized
Extern variable cannot be initialized	Compiler-Meldung

Die Speicherklasse extern bedeutet für eine Variable, daß sie hier deklariert, aber nicht definiert wird und kein Speicherplatz für sie vorgesehen ist.

Deshalb kann sie in der Deklaration noch nicht initialisiert werden.


Cannot initialize 'type1' with 'type2'
Cannot initialize 'type1' with 'type2'	Compiler-Meldung

Ein Objekt des Typs Typ1 kann nicht mit einem Wert des Typs Typ2 initialisiert werden

Es gelten im wesentlichen die normalen Zuweisungsregeln.


Objects of type 'type' cannot be initialized with {}
Objects of type 'type' cannot be initialized with {}	Compiler-Meldung

Gewöhnliche Strukturen in C können mit einer Anzahl von Werten in geschweiften Klammern initialisiert werden.

Klassen können in C++ nur durch Konstruktoren initialisiert werden, wenn die Klasse Konstruktoren, private Elemente, Funktionen oder Basisklassen enthält, die virtuell sind.


Operator new must return an object of type void *

Operator new[] must return an object of type void *	Compiler-Meldung

Dieser überladene C++ Operator new muß genau ein Objekt des Typs void * zurückliefern und war hier anders deklariert.


'function' must be declared with no parameters
'function' must be declared with no parameters	Compiler-Meldung

Diese C++ Operatorfunktion muß ohne Parameter deklariert werden.


'function' must be declared with one parameter
'function' must be declared with one parameter	Compiler-Meldung

Diese C++ Operatorfunktion muß mit genau einem Parameter deklariert werden.


'function' must be declared with two parameters
'function' must be declared with two parameters	Compiler-Meldung

Diese C++ Operatorfunktion muß mit genau zwei Parametern deklariert werden.


'identifier' must be a member function or have a parameter of class type
'identifier' must be a member function or have a parameter of class type	Compiler-Meldung

Die meisten C++ Operatorfunktionen müssen einen expliziten oder impliziten Parameter des Typs class aufweisen.

Diese Operatorfunktion wurde außerhalb einer Klasse deklariert und enthält keinen expliziten Parameter vom Typ class.


Only one of a set of overloaded functions can be "C"
Only one of a set of overloaded functions can be "C"	Compiler-Meldung

Alle C++ Funktionen werden per Voreinstellung überladen, wobei der Compiler jeder Funktion einen neuen Namen zuweist.

Wollen Sie diese Umbenennung verhindern, indem Sie die Funktion als extern C deklarieren, so dürfen Sie das nur bei einer Funktion aus einer Gruppe von Funktionen mit gleichem Namen tun.

(Sonst würde der Linker mehr als eine globale Funktion mit demselben Namen finden.)


'identifier' is not a parameter
'identifier' is not a parameter	Compiler-Meldung

In einer Funktionsdefinition des alten Stils wird der Bezeichner Bezeichner deklariert, aber nicht als Parameter aufgelistet. Entfernen Sie die Deklaration oder ergänzen Sie den Bezeichner Bezeichner als Parameter.


Qualifier 'identifier' is not a class or namespace name
Qualifier 'identifier' is not a class or namespace name	Compiler-Meldung

Der C++ Qualifizierer in der Konstruktion Qualifizierer::Bezeichner ist nicht der Name einer Struktur oder einer Klasse.


Two operands must evaluate to the same type
Two operands must evaluate to the same type	Compiler-Meldung

Im Bedingungsoperator ?: müssen die Typen der Ausdrücke auf beiden Seiten des Doppelpunkts dieselben sein, außer bei den gängigen Umwandlungen.

Einige Beispiele für gängige Umwandlungen:

 	char nach int

 	float nach double

 	void* in einen besonderen Zeiger.

Hier ergeben die beiden Seiten verschiedene Datentypen, die nicht automatisch umgewandelt werden..

Unter Umständen brauchen Sie bloß eine Seite in den Datentyp der anderen umzuwandeln.

In C++ erhalten Sie zu dieser Meldung eine weitere, die Ihnen das Problem genauer erklärt.

Sie lautet gewöhnlich "Cannot convert 'type1' to 'type2'" ("kann Typ1 nicht in Typ2 umwandeln"), die Gründe für die Typenunverträglichkeit können jedoch vielfältiger Natur sein.


'this' can only be used within a member function
'this' can only be used within a member function	Compiler-Meldung

In C++ ist this ein reserviertes Wort, das nur innerhalb von Elementfunktionen von Klassen verwendet werden kann.


Virtual function 'function1' conflicts with base class 'base'
Virtual function 'function1' conflicts with base class 'base'	Compiler-Meldung

Eine virtuelle Funktion hat dieselben Argumenttypen wie eine Funktion einer Basisklasse, liefert aber einen anderen Ergebnistyp. Dies ist unzulässig.


Bit field too large
Bit field too large	Compiler-Meldung

Die Größe eines Bitfeldes darf 16 Bits nicht überschreiten.


Bit fields must contain at least one bit
Bit fields must contain at least one bit	Compiler-Meldung

Ein benanntes Bitfeld darf nicht 0 oder weniger Bit enthalten.

Ein nicht benanntes Bitfeld darf 0 Bit enthalten.

Dies ist erlaubt, um die Ausrichtung des folgenden Bitfeldes an einer Bytegrenze (oder an eine Wortgrenze) zu erzwingen.


Overloadable operator expected
Overloadable operator 	Compiler-Meldung

Fast alle C++ Operatoren können überladen werden.

Die einzigen nicht überladbaren Operatoren sind die folgenden:

 	Der Punkt für die Feldauswahl (.).

 	Der Punkt-Stern (.*).

 	Der doppelte Doppelpunkt (::).

 	Der bedingte Ausdruck (?:).

Die Operatoren # und ## für den Präprozessor stammen nicht aus den Sprachen C oder C++ und können deshalb nicht überladen werden.

Interpunktionszeichen wie der Strichpunkt (;) sind keine Operatoren und können daher auch nicht überladen werden.


Default argument value redeclared
Default argument value redeclared	Compiler-Meldung

Wenn ein Parameter einer C++ Funktion mit einem Vorgabewert deklariert ist, kann dieser Wert bei einer weiteren Deklaration derselben Funktion nicht verändert, nicht redeklariert und nicht weggelassen werden.


Default argument value redeclared for parameter 'parameter'
Default argument value redeclared for parameter 'parameter'	Compiler-Meldung

Wenn ein Parameter einer C++ Funktion mit einem Vorgabewert deklariert ist, kann dieser Wert bei einer weiteren Deklaration derselben Funktion nicht verändert, nicht redeklariert und auch nicht weggelassen werden.


Declaration is not allowed here
Declaration is not allowed here	Compiler-Meldung

Deklarationen sind als Kontrollanweisungen für while, for, do, if oder switch nicht erlaubt.


Array allocated using 'new' may not have an initializer
Array allocated using 'new' may not have an initializer	Compiler-Meldung

Beim Initialisieren eines Vektors (oder Vektorarrays) von Klassen muß ein Konstruktor ohne Argumente verwendet werden.

Dieser Konstruktor heißt Standardkonstruktor. Das bedeutet, daß bei der Initialisierung eines solchen Vektors keine Konstruktorargumente angegeben werden dürfen.


Trying to derive a far class from the near base 'base'
Trying to derive a far class from the near base 'base'	Compiler-Meldung

Ist die Deklaration oder Voreinstellung einer Klasse near, müssen alle abgeleiteten Klassen dies ebenfalls sein.


Trying to derive a near class from the far base 'base'
Trying to derive a near class from the far base 'base'	Compiler-Meldung

Ist die Deklaration oder Voreinstellung einer Klasse far, müssen alle abgeleiteten Klassen dies ebenfalls sein.


Destructor for class is not accessible
Destructor for class is not accessible	Compiler-Meldung

Der Destruktor für diese C++ Klasse ist protected oder private und kann hier nicht verwendet werden, um die Klasse zu löschen.

Ist ein Klassendestruktor private, kann die Klasse nicht gelöscht und daher auch nie benutzt werden. Dies ist vermutlich ein Programmierfehler.

Auf einen Destruktor vom Typ protected kann nur über abgeleitete Klassen zugegriffen werden.

Dies ist eine praktische Methode, um keine Instanzen einer Basisklasse, sondern nur abgeleitete Klassen zuzulassen.


Division by zero (error)
Division by zero	Compiler-Meldung

Ein konstanter Ausdruck in Ihrer Quelldatei enthält eine Division durch Null.


Too many default cases
Too many default cases	Compiler-Meldung

Eine switch-Anweisung darf nur einen einzigen default-Zweig haben.


'identifier' specifies multiple or duplicate access
'identifier' specifies multiple or duplicate access	Compiler-Meldung

Eine Basisklasse kann public oder private deklariert werden, aber nicht beides zugleich.

Der Zugriffsbezeichner darf für die Basisklasse nur einmal erscheinen.


Base class 'class' is included more than once
Base class 'class' is included more than once	Compiler-Meldung

Eine C++ Klasse kann von beliebig vielen Basisklassen abgeleitet werden, direkt von einer gegebenen Klasse aber nur einmal.


Duplicate case
Duplicate case	Compiler-Meldung

Der Wert einer jeden case-Marke einer switch-Anweisung darf nur einmal vorkommen.


Member 'member' is initialized more than once
Member 'member' is initialized more than once	Compiler-Meldung

In einem C++ Klassenkonstruktor enthält die Initialisierungsliste nach dem Konstruktorkopf denselben Elementnamen mehrmals.


Multiple declaration for 'identifier'
Multiple declaration for 'identifier'	Compiler-Meldung

Der Bezeichner wurde fälschlicherweise mehrfach deklariert.

Dies kann aus widersprüchlichen Angaben herrühren wie:

 	int a; double a;

 	Einer zweimal und verschieden deklarierten Funktion.

 	Einer wiederholten Sprungmarke in derselben Funktion.

 	Einer wiederholten Deklaration, außer bei einer extern-Funktion oder einer einfachen Variable.

Dieses kann auch passieren, wenn die gleiche Header-Datei zweimal eingebunden wird. Zum Beispiel:

//a.h

struct A { int a; };

//b.h

#include "a.h"

//myprog.cpp

#include "a.h"

#include "b.h"

MYPROG.CPP erhält zwei Deklarationen für struct A. Um diese zu verhindern, schreibt man am besten in der Header-Datei A.H:

//a.h

#ifndef __A_H

#define __A_H

struct A { int a; };

#endif

Dieses erlaubt ein sicheres, mehrfaches Einbinden von A.H in die gleiche Quelltextdatei.


Base class 'class' is initialized more than once
Base class 'class' is initialized more than once	Compiler-Meldung

Im Konstruktor einer C++ Klasse enthält die Liste der Initialisierungen nach dem Konstruktorkopf mehr als einmal die Basisklasse Klasse.


'specifier' has already been included
'specifier' has already been included	Compiler-Meldung

Der Typ Spezifizierer taucht in der Deklaration öfter als einmal auf.

Löschen oder ändern Sie das an einer Stelle.


Body has already been defined for function 'function'
Body has already been defined for function 'function'	Compiler-Meldung

Für die Funktion dieses Namens und Typs existiert schon ein Funktionsrumpf.

Ein Funktionsrumpf kann nur einmal definiert werden.

Ein möglicher Grund für diesen Fehler ist, daß Sie einen implementierten Standardkonstruktor nicht deklariert haben. Zum Beispiel:

class A {

public:

   virtual myex();

};

A::A() {} // Fehler

Der Compiler hat keinen Standardkonstruktor in der Klassendeklaration gefunden und hat selbst einen generiert. Die Fehlermeldung erscheint, wenn der Compiler den Standardkonstruktor, der oben nicht deklariert wurde, findet. Hier ein korrektes Beispiel:

class A {

public:

   A();

   virtual myex();

};

A::A() {}


virtual specified more than once
virtual specified more than once	Compiler-Meldung

In C++ darf das reservierte Wort virtual in der Deklaration einer Elementfunktion nur einmal auftreten.


File must contain at least one external declaration
File must contain at least one external declaration	Compiler-Meldung

Der Inhalt dieser Compilierungseinheit war logisch leer, weil sie keine externen Deklarationen enthielt.

In ANSI C und C++ muß etwas in der zu compilierenden Einheit deklariert werden.


'member' is not accessible
'member' is not accessible	Compiler-Meldung

Sie versuchen, auf ein Element einer C++ Klasse zuzugreifen, das private oder protected und aus dieser Funktion heraus nicht zugänglich ist.

Dies geschieht manchmal, wenn eine zugängliche überladene Funktion (oder ein Konstruktor) angesprochen werden soll und die Argumente zu einer unzugänglichen Funktion passen.

Mögliches Überladen wird immer vor den Zugriffsrechten geprüft.

Nehmen Sie eine explizite Typumwandlung bei einem oder mehreren Parametern vor, um den richtigen Zugriff zu ermöglichen.

Konstruktoren von virtuellen Basisklassen müssen von den abgeleiteten Klassen erreichbar sein, da C++ immer zuerst die virtuellen Basisklassen erstellt und zwar unabhängig von ihrer Position in der Klassenhierarchie. Zum Beispiel:

class A {

public:

   A();

};

class B : private virtual A {};

class C : private B {

public:

C();

};

C::C() {} // Fehler, A::A() ist nicht zugänglich

Da B von A und C von B private abgeleitet wird, ist der Konstruktor von A für C nicht erreichbar. Jedoch muß der Konstruktor von C die Möglichkeit haben, auf den Konstruktor der virtuellen Basisklasse A zuzugreifen. Verwendet man statt dessen eine public-Vererbung von A nach B, dann funktioniert obiges Beispiel.


Function defined inline after use as extern
Function defined inline after use as extern	Compiler-Meldung

Nach der Verwendung einer Funktion kann diese nicht mehr inline deklariert werden.

Verlagern Sie die inline-Deklaration im Quelltext weiter nach vorne oder löschen Sie sie ganz.

Der Compiler entdeckte so etwas wie:

myex();

twoex() { myex(); }

inline myex() { return 2; } // error

und verwendete die Funktion bereits als extern, bevor er erkannte, daß sie als inline spezifiziert wurde.

myex();

inline myex() { return 2; }

twoex() { myex(); }

oder besser:

inline myex();

inline myex() { return 2; }

twoex() { myex(); }


Undefined label 'identifier'
Undefined label 'identifier'	Compiler-Meldung

Die bezeichnete Sprungadresse soll zwar via goto angesprungen werden, ist aber innerhalb der Funktion nicht definiert.


Unexpected }
Unexpected }	Compiler-Meldung

Eine überzählige schließende Klammer wurde aufgefunden. Suchen Sie nach einer fehlenden öffnenden Klammer.

Nützlicher Hinweis:

Die Entwicklungsumgebung besitzt einen Mechanismus, um passende Klammern zu finden. Positionieren Sie den Cursor auf das Zeichen "{"oder das Zeichen "}" und betätigen Sie die Tastenkombination Strg+Q. Der Mauszeiger wird dann an der passenden Klammer positioniert.


Ambiguity between 'function1' and 'function2'
Ambiguity between 'function1' and 'function2'	Compiler-Meldung

Beide überladenen Funktionen können über die angegebenen Parameter angesprochen werden.

Diese Mehrdeutigkeit ist nicht zulässig.


Class member 'member' declared outside its class
Class member 'member' declared outside its class	Compiler-Meldung

Elementfunktionen einer C++ Klasse können nur in der Klassendeklaration deklariert werden.

Sie können nicht wie andere Funktionen mehrfach oder an anderen Stellen deklariert werden.


'constructor' is not an unambiguous base class of 'class'
'constructor' is not an unambiguous base class of 'class'	Compiler-Meldung

Ein Klassenkonstruktor versucht den Basisklassenkonstruktor Konstruktor aufzurufen.

Oder Sie versuchen, die Zugriffsrechte von class::Konstruktor zu verändern.

Bitte überprüfen Sie Ihre Deklarationen.


'identifier' must be a member function
'identifier' must be a member function	Compiler-Meldung

Die meisten Operatorfunktionen von C++ können Elemente von Klassen oder gewöhnliche Nicht-Elementfunktionen sein. Die folgenden müssen aber Elemente von Klassen sein:

 	Operator =.

 	Operator ->.

 	Operator ( ).

 	Typumwandlungen.

Diese Operatorfunktion ist keine Elementfunktion, sie sollte es aber sein.


Parameter 'number' missing name
Parameter 'number' missing name	Compiler-Meldung

Im Kopf der Funktionsdefinition stand hier nur die Typangabe Nummer ohne Parameternamen.

In C ist dies unzulässig.

(In C++ ist es zwar erlaubt, es ist aber dann kein Zugriff auf den Parameter der Funktion möglich.)


No base class to initialize
No base class to initialize	Compiler-Meldung

Dieser C++ Klassenkonstruktor versucht implizit den Klassenkonstruktor einer Basisklasse aufzurufen.

Für diese Klasse wurde aber keine Basisklasse deklariert.

Überprüfen Sie Ihre Deklarationen.


Illegal to take address of bit field
Illegal to take address of bit field	Compiler-Meldung

Es ist nicht gestattet, die Adresse eines Bitfeldes zu verwenden. Bei anderen Feldern ist dies erlaubt.


Cannot initialize a class member here
Cannot initialize a class member here	Compiler-Meldung

Einzelne Elemente einer Struktur, Union oder Klasse in C++ können keine Initialisierer haben.

Eine Struktur oder Union kann als Ganzes mit Initialisierungswerten in geschweiften Klammern initialisiert werden.

Eine C++ Klasse kann nur durch einen Konstruktor initialisiert werden.


: expected after private/protected/public
: expected after private/protected/private	Compiler-Meldung

Am Beginn eines entsprechenden Abschnitts einer C++ Klasse muß auf die reservierten Wörter private, protected und public ein Doppelpunkt folgen.


No : following the ?
No : following the ?	Compiler-Meldung

In diesem Ausdruck sind die Operatoren ? und : falsch plaziert.

Vielleicht fehlt der Doppelpunkt, oder Klammern sind falsch verschachtelt oder fehlen.


, expected
, expected	Compiler-Meldung

In einer Liste von Deklarationen, Initialisierungen oder Parametern wird ein Komma erwartet.

Ursache für diese Meldung ist oft ein fehlendes Syntaxelement weiter vorne im Quelltext oder in einer der Header-Dateien.


Cannot find class::class/operator (class &) to copy a vector
Cannot find 'class::class' ('class'&) to copy a vector	Compiler-Meldung

ODER	Cannot find 'class'::operator=('class'&) to copy a vector

Kann Klasse::Klasse nicht finden...

Enthält eine C++ Klasse Klasse1 einen Vektor (Array) aus Klasse Klasse2, und Sie wollen ein Objekt des Typs Klasse1 aus einem anderen Objekt dieser Klasse erstellen, müssen Sie diesen Konstruktor verwenden:

Klasse2::Klasse2(Klasse2&)

Dadurch können die Elemente des Vektors konstruiert werden.

Der Konstruktor, Kopierkonstruktor genannt, braucht nur einen Parameter als Referenz zu seiner Klasse.

Der Kopierkonstruktor wird üblicherweise automatisch vom Compiler geliefert.

Wenn Sie aber einen Konstruktor für die Klasse Klasse2 definiert haben mit einem Parameter des Typs Klasse2& und mit zusätzlichen Parametern mit Voreinstellung, dann kann kein Kopierkonstruktor existieren oder vom Compiler erzeugt werden.

Der Grund dafür ist, daß die folgenden Deklarationen nicht unterschieden werden können:

Klasse2::Klasse2(Klasse2&)

Klasse2::Klasse2(Klasse2&, int = 1)

Sie müssen den Konstruktor so definieren, daß nicht alle Parameter Vorgabewerte haben.

Dann können Sie einen Referenzkonstruktor definieren oder vom Compiler erzeugen lassen.

Kann Klasse::operator=  nicht finden

Enthält eine C++ Klasse Klasse1 einen Vektor (Array) aus Klasse Klasse2, und Sie wollen ein Objekt des Typs Klasse1 kopieren, müssen Sie diesen Zuweisungsoperator verwenden:

Klasse2::Klasse2(Klasse2&)

Dadurch können die Elemente des Vektors kopiert werden.

Normalerweise wird dieser Operator vom Compiler bereitgestellt.

Dies ist jedoch nicht der Fall, wenn Sie einen Operator = für die Klasse Klasse2 definiert haben, der keinen Parameter des Typs Klasse2& übernimmt. In diesem Fall müssen Sie selbst einen solchen Operator zur Verfügung stellen.


Declaration was expected
Declaration was expected	Compiler-Meldung

Hier wurde eine Deklaration erwartet, aber nicht gefunden.

Dies ist meist auf fehlende Begrenzer wie Komma, Semikolon, abschließende Anführungszeichen oder abschließende Klammern zurückzuführen.


'identifier' must be a previously defined enumeration tag
'identifier' must be a previously defined enumeration tag	Compiler-Meldung

Sie versuchen Bezeichner als Teil eines enum anzusprechen, er wurde aber nicht so deklariert.

Ändern Sie den Namen oder die Deklarationen.


Expression expected
Expression expected	Compiler-Meldung

Hier wird ein Ausdruck erwartet, der mit dem aktuellen Zeichen aber nicht beginnen kann.

Dieser Fehler tritt eventuell beim Steuerausdruck für eine if- oder while-Anweisung oder beim Initialisieren einer Variablen auf.

Der Fehler tritt oft wegen eines versehentlich eingefügten oder gelöschten Zeichens auf.


Member identifier expected
Member identifier expected	Compiler-Meldung

Es wird hier der Name eines Feldes einer Struktur oder einer C++ Klasse erwartet, aber nicht gefunden. Rechts vom Punkt (.) oder Pfeil (->) muß ein Feldname der Struktur oder Klasse, die auf der linken Seite angegeben wurde, folgen.


'identifier' is not a member of struct
'identifier' is not a member of 'struct'	Compiler-Meldung

Sie versuchen fälschlicherweise, einen Bezeichner als Element einer Struktur zu behandeln.

Überprüfen Sie Ihre Deklarationen.


Friends must be functions or classes
Friends must be functions or classes	Compiler-Meldung

Friends einer C++ Klasse müssen Funktionen oder Klassen sein.


Functions may not be part of a struct or union
Functions may not be part of a struct or union	Compiler-Meldung

Hier wurde ein Feld eines struct oder union als Funktion anstatt als Zeiger auf eine Funktion deklariert.

Nur in C++ sind Felder als Funktionen erlaubt.


Identifier expected
Identifier expected	Compiler-Meldung

Hier wurde ein Bezeichner erwartet, aber nicht gefunden.

In C wird in folgenden Situationen ein Bezeichner erwartet:

 	Bei einer Parameterliste in einem Funktionskopf im alten Stil.

 	Nach den reservierten Worten struct und union, wenn keine Klammern folgen.

 	Als Elementname in einer Struktur oder Union (außer bei Bitfeldern der Breite 0).

In C++ wird zusätzlich in diesen Situationen ein Bezeichner erwartet:

 	Wenn eine Liste von Basisklassen auftritt, von der eine weitere Klasse abgeleitet wird, und zwar nach dem doppelten Doppelpunkt (::).

 	Nach dem reservierten Begriff operator, wenn kein Operator folgt.


Constant/Reference variable 'variable' must be initialized
Constant/Reference variable 'variable' must be initialized	Compiler-Meldung

Das C++ Objekt ist als const oder als Referenz deklariert, aber nicht initialisiert.

Es muß bei der Deklaration initialisiert werden.


Inline assembly not allowed in inline and template functions
Inline assembly not allowed in inline and template functions	Compiler-Meldung

Der Compiler kann in einer C++ Inline- oder einer C++ Template-Funktion Assembler-Ausdrücke, die Inline sind, nicht bearbeiten.

Sie können den Inline-Assemblercode löschen oder, wenn es sich um eine Inline-Funktion handelt, daraus ein Makro machen und die Speicherklasse inline entfernen.


{ expected
{ expected	Compiler-Meldung

Beim Beginn eines Blocks oder einer Initialisierung wird { erwartet.


Attempting to return a reference to local variable 'identifier'
Attempting to return a reference to local variable 'identifier'	Compiler-Meldung

Diese C++ Funktion liefert eine Referenz, die sich auf eine lokale (auto) Variable beziehen soll.

Dies ist nicht zulässig, weil die lokale Variable beim Verlassen der Funktion verschwindet.

Sie können eine Referenz auf eine statische oder globale Variable zurückliefern. Es ist auch möglich, die Funktion so zu ändern, daß sie einen Wert anstatt einer Referenz liefert.


( expected
( expected	Compiler-Meldung

Vor einer Parameterliste wird ( erwartet.


Reference member 'member' is not initialized
Reference member 'member' is not initialized	Compiler-Meldung

Referenzen müssen immer im Konstruktor der Klasse initialisiert werden.

Ein Klassenelement vom Referenztyp braucht eine Initialisierungsgröße in allen Konstruktoren dieser Klasse.

Das bedeutet, daß Sie sich nicht darauf verlassen können, daß der Compiler auch für eine derartige Klasse Konstruktoren generiert, weil er nicht wissen kann, wie er die Referenzen initialisieren soll.


Could not find a match for argument(s)
Could not find a match for argument(s)	Compiler-Meldung

Für die Argumente wurde keine Funktion mit passenden Parametern gefunden. Überprüfen Sie die an Funktionen oder überladene Funktionen übergebenen oder zu übergebenden Parameter.


Use :: to take the address of a member function
Use :: to take the address of a member function	Compiler-Meldung

Ist f eine Elementfunktion der Klasse c, erhält man deren Adresse über

&c::f

Beachten Sie, daß ein Klassenname und nicht der Name eines Objektes verwendet wird, und daß ein doppelter Doppelpunkt zwischen Klasse und Funktion stehen muß.

(Zeiger auf Elementfunktionen sind keine echten Zeiger und beziehen sich auf keine besondere Instanz einer Klasse).


Cannot find default constructor to initialize base class 'class'
Cannot find default constructor to initialize base class 'class'	Compiler-Meldung

Wenn in C++ eine abgeleitete Klasse Klasse2 erstellt wird, muß eine Basisklasse Klasse1 schon existieren.

Falls der Konstruktor für Klasse2 keinen Konstruktor von Klasse1 (als Teil des Kopfes von Klasse2) angibt, muß es einen Konstruktor Klasse1::Klasse1() für die Basisklasse geben.

Dieser parameterlose Konstruktor heißt Standardkonstruktor.

Der Standardkonstruktor wird üblicherweise vom Compiler bereitgestellt, es sei denn, Sie haben selbst einen Konstruktor für die Klasse Klasse1 definiert.

In diesem Fall müssen Sie selbst einen Konstruktor bereitstellen.

class Base {

public:

   Base(int) {}

};

class Derived = public Base {

   Derived():Base(1) {}

}

// Sie müssen den Konstruktor der Basisklasse explizit aufrufen oder

// einen Standardkonstruktor zur Verfügung stellen

Klassenelemente mit Konstruktor müssen in der Initialisierungsliste der Klasse initialisiert werden:

class A {

public

   A( int );

};

class B {

public:

   A a;

   B() : a( 3 ) {}; //ok

};


Cannot find default constructor to initialize member 'identifier'
Cannot find default constructor to initialize member 'identifier'	Compiler-Meldung

In den folgenden Situationen muß ein Konstruktor Klasse2::Klasse2() existieren, damit das Element erstellt werden kann:

1.	Wenn eine C++ Klasse Klasse1 ein Element der Klasse Klasse2 enthält, und:

2.	Wenn Sie ein Objekt der Klasse Klasse1, aber nicht aus einem anderen Objekt von Klasse1 erstellen wollen.

Dieser Konstruktor ohne Parameter wird Standardkonstruktor genannt.

Der Standardkonstruktor wird üblicherweise vom Compiler bereitgestellt, es sei denn, es existiert schon ein Konstruktor für Klasse2.

In diesem Fall müssen Sie selbst einen Konstruktor bereitstellen.


Use . or -> to call function
Use . or -> to call function	Compiler-Meldung

Sie haben versucht, eine Elementfunktion aufzurufen, ohne ein Objekt anzugeben. *this wird aber für den Aufruf benötigt.

class X {

   member func() {}

};

X x;

X*xp = new X;

X.memberfunc();

Xp-> memberfunc();


missing ]
missing ]	Compiler-Meldung

Bei dieser Meldung liegt eine der folgenden Situationen vor:

 	Wenn Sie ein Array ohne abschließende rechte Klammer definiert haben.

 	Wenn dem Array-Bezeichner in einem Operator die abschließende rechte Klammer fehlt.

 	Wenn der Operator [ ] als Operator [ deklariert wurde.

 	Wenn in einem Indizierungsausdruck die abschließende rechte Klammer fehlt.

Fügen Sie die Klammer hinzu oder berichtigen Sie die Deklaration.

Suchen Sie nach fehlenden oder überzähligen Operatoren oder nach falsch gesetzten Klammern.


} expected
} expected	Compiler-Meldung

Am Ende eines Blocks oder einer Initialisierung wird eine abschließende rechte Klammer erwartet.


Must take address of a memory location
Must take address of a memory location	Compiler-Meldung

Sie haben den AdreßOperator (&) mit einem unzulässigen Ausdruck verwendet, z.B. einer Registervariablen.


) expected
) expected	Compiler-Meldung

Am Ende einer Parameterliste wird eine abschließende rechte Klammer erwartet.


Statement missing ;
Statement missing ;	Compiler-Meldung

Einem Ausdruck fehlt ein abschließendes Semikolon (;).


Bit field cannot be static
Bit field cannot be static	Compiler-Meldung

Nur Elemente einer gewöhnlichen C++ Klasse können static deklariert werden, Bitfelder nicht.


Global anonymous union not static
Global anonymous union not static	Compiler-Meldung

In C++ muß eine globale anonyme Variante auf Dateiebene static sein.


Structure required on left side of . or .*
Structure required on left side of . or .*	Compiler-Meldung

Links vom Punkt-Operator (oder in C++ dem Punkt-Stern-Operator) muß eine Struktur stehen.

Sie haben vielleicht eine Instanz einer Klasse mit leeren Klammern {} erzeugt und dann versucht, auf ein Element dieses Objektes zuzugreifen.


Constant expression required
Constant expression required	Compiler-Meldung

Die Größen von Arrays müssen als konstante Werte angegeben sein.

Dieser Fehler wird häufig durch einen Tippfehler in einer #define-Konstanten verursacht.


Call of nonfunction
Call of nonfunction	Compiler-Meldung

Bei dem angegebenen Bezeichner handelt es sich nicht um eine Funktion.

Sie haben wahrscheinlich die Funktion falsch deklariert oder sich beim Funktionsnamen vertippt.


Case outside of switch
Case outside of switch	Compiler-Meldung

Eine case-Marke ist nur innerhalb einer switch-Anweisung zulässig.

Hier handelt es sich normalerweise um eine falsch plazierte geschweifte Klammer.


Member pointer required on right side of .* or ->*
Member pointer required on right side of .* or ->*	Compiler-Meldung

Die rechte Seite des C++ Operators Punkt-Stern (.*) oder Pfeil-Stern (->*) muß als Zeiger auf ein Element der Klasse deklariert werden, die links vom Operator steht.

Hier steht rechts kein Zeiger auf ein Element.


Type name expected
Type name expected	Compiler-Meldung

Einer der folgenden Fehler ist aufgetreten:

 	Bei der Deklaration einer Variablen auf Dateiebene oder eines struct-Feldes wurde weder Datentyp noch Speicherklasse angegeben.

 	Bei der Deklaration eines typedef wurde kein Datentyp angegeben.

 	Bei der Deklaration eines Destruktors für eine C++ Klasse war der Destruktorname kein Typname, er muß zu seiner Klasse passen.

 	Der Name einer C++ Basisklasse war nicht der einer Klasse.


union cannot have a base type
union cannot have a base type	Compiler-Meldung

Im allgemeinen gilt, daß eine C++ Klasse vom Typ union sein kann, solch eine Klasse kann aber nicht von anderen Klassen abgeleitet werden.


Value of type void is not allowed
Value of type void is not allowed	Compiler-Meldung

Ein Wert vom Typ void ist eigentlich kein Wert und darf deshalb nicht in Fällen verwendet werden, in denen ein Wert erforderlich ist.

Solche Fälle sind:

 	Die rechte Seite einer Zuweisung.

 	Das Argument einer Funktion.

 	Die Steueranweisungen der Ausdrücke if, for oder while.


do statement must have while
do statement must have while	Compiler-Meldung

Einer do-Schleife fehlt das abschließende Schlüsselwort while.


Identifier 'identifier' cannot have a type qualifier
Identifier 'identifier' cannot have a type qualifier	Compiler-Meldung

Der C++ Qualifizierer Klasse::Bezeichner ist hier nicht erlaubt.

Ein Qualifizierer ist nicht erlaubt bei:

 	Typedef-Namen.

 	Funktionsdeklarationen (außer Definitionen auf Dateiebene).

 	Vor lokalen Variablen oder Funktionsparametern.

 	Bei Klassenelementen, außer als Qualifizierer der eigenen Klasse, was redundant, aber zulässig ist.


sizeof may not be applied to a bit field
sizeof may not be applied to a bit field	Compiler-Meldung

sizeof liefert die Größe eines Datenobjekts in Bytes, dies ist für ein Bitfeld nicht definiert.


sizeof may not be applied to a function
sizeof may not be applied to a function	Compiler-Meldung

sizeof darf nur auf Datenobjekte, nicht auf Funktionen angewendet werden.

Die Größe eines Zeigers auf eine Funktion können Sie aber mit sizeof ermitteln.


Storage class 'storage class' is not allowed here
Storage class 'storage class' is not allowed here	Compiler-Meldung

Die angegebene Speicherklasse ist hier nicht erlaubt.

Vermutlich wurden zwei Speicherklassen angegeben, nur eine ist jedoch erlaubt.


Access can only be changed to public or protected
Access can only be changed to public or protected	Compiler-Meldung

Eine abgeleitete Klasse in C++ kann die Zugriffsrechte eines Basiselements der Basisklasse nur in public oder protected verändern.

Ein Element einer Basisklasse kann nicht in private verändert werden.


Variable 'identifier' is initialized more than once
Variable 'identifier' is once	Compiler-Meldung

Diese Variable wird hier zum wiederholten Mal initialisiert. Auf Dateiebene darf eine Variable zwar mehrmals deklariert, aber nur einmal initialisiert werden (selbst wenn die Initialisierungen identisch sind).


Improper use of typedef 'identifier'
Improper use of typedef 'identifier'	Compiler-Meldung

Ihr Quelltext verwendet ein typedef-Symbol, wo eine Variable in einem Ausdruck stehen sollte.

Überprüfen Sie die Deklaration des Symbols und auf mögliche Tippfehler.


Size of 'identifier' is unknown or zero
Size of 'identifier' is unknown or zero	Compiler-Meldung

Dieser Bezeichner wurde in einem Zusammenhang verwendet, in dem seine Größe gebraucht wurde.

Ein struct-Kennungsname darf alleine (noch ohne Definition von struct), ein extern-Array darf ohne Größenangabe deklariert werden.

Dann ist es aber nicht zulässig, sich auf eine derartige Konstruktion zu beziehen (z.B. mit sizeof) oder einen Zeiger auf diesen Typ zu dereferenzieren.

Verändern Sie die Deklaration so, daß die Größe von Bezeichner verfügbar ist.


Size of the type 'identifier' is unknown or zero
Size of the type 'identifier' is unknown or zero	Compiler-Meldung

Dieser Typ wurde in einem Zusammenhang verwendet, in dem seine Größe gebraucht wurde.

Ein struct-Kennungsname z.B. darf alleine (noch vor der Definition des struct) deklariert werden.

Dann ist es aber nicht zulässig, sich auf eine derartige Konstruktion zu beziehen (z.B. mit sizeof) oder einen Zeiger auf diesen Typ zu dereferenzieren.

Verändern Sie Ihre Deklaration so, daß die benötigte Größe verfügbar ist.


Size of the type is unknown or zero
Size of the type is unknown or zero	Compiler-Meldung

Diese Fehlermeldung weist darauf hin, daß ein Array unbekannter Größe sich innerhalb einer anderen Struktur befindet, und der Schalter -A (ANSI) gesetzt ist. Zum Beispiel so:

struct

{

char a[]; 	// Größe von 'a' ist unbekannt oder Null

}

b = { "hello" }; 	// Größe des Typs ist

// unbekannt oder Null


Conversion operator cannot have a return type specification
Conversion operator cannot have a return type specification	Compiler-Meldung

Diese Typumwandlungsfunktion für ein C++ Element gibt an, daß ein abweichender Typ zurückgeliefert wird.

Eine Deklaration für einen Umwandlungsfunktionsoperator darf überhaupt keinen Rückgabetypen angeben.


Linkage specification not allowed
Linkage specification not allowed	Compiler-Meldung

Bindungsspezifikationen wie extern "C" sind nur auf Dateiebene erlaubt.

Versetzen Sie die Funktionsdeklaration auf die Dateiebene.


Reference member 'member' needs a temporary for initialization
Reference member 'member' needs a temporary for initialization	Compiler-Meldung

Sie haben einen Initialisierungswert für einen Referenztyp angegeben, der kein L-Wert des referenzierten Typs war.

Der Compiler erzeugt dann eine temporäre Größe für die Initialisierung.

Weil es keinen offensichtlichen Platz für diese temporäre Größe gibt, ist diese Initialisierung unzulässig.


'identifier' cannot be declared in an anonymous union
'identifier' cannot be declared in an anonymous union	Compiler-Meldung

Der Compiler hat eine Deklaration einer Elementfunktion oder eines statischen Elements in einer anonymen Variante gefunden.

Solche Varianten können nur Datenelemente enthalten.


Function 'function' cannot be static
Function 'function' cannot be static	Compiler-Meldung

Nur gewöhnliche Elementfunktionen und die Operatoren new und delete können static deklariert werden.

Konstruktoren, Destruktoren und andere Operatoren dürfen nicht static sein.


Cannot overload 'main'
Cannot overload 'main'	Compiler-Meldung

main ist die einzige Funktion, die nicht überladen werden kann.


Non-virtual function 'function' declared pure
Non-virtual function 'function' declared pure	Compiler-Meldung

Nur virtuelle Funktionen können als abstrakte Funktionen deklariert werden, damit abgeleitete Klassen sie überschreiben können.


Bad syntax for pure function definition
Bad syntax for pure function definition	Compiler-Meldung

Abstrakte Funktionen kennzeichnet man durch ein "= 0" am Ende der Funktionsdeklaration, z.B. so:

class A { virtual void f () = 0;}

class B : public A { void f () {}; }

Sie haben möglicherweise etwas ähnliches geschrieben, aber nicht dasselbe.


Cannot create instance of abstract class 'class'
Cannot create instance of abstract class 'class'	Compiler-Meldung

Abstrakte Klassen (solche mit abstrakten Funktionen) können nicht direkt verwendet werden, d.h., es kann keine Instanz erzeugt werden. Es kann von ihnen nur abgeleitet werden.

Wenn Sie von einer abstrakten Basisklasse ableiten und dabei die Absicht haben, Instanzen dieser abgeleiteten Klasse zu instantiieren, dann müssen Sie jede der abstrakten Funktionen der Basisklasse in der deklarierten Form überschreiben.

Zum Beispiel:

class A {

public:

   virtual myex( int ) = 0;

   virtual twoex( const int ) const = 0;

};

class B : public A {

public:

   myex( int );

   twoex( const int );

};

B b;   // Fehler

Da die virtuelle Funktion twoex nicht überschrieben, sondern statt dessen eine neue erzeugt wurde, die mit nicht konstanten Objekten arbeitet, entsteht dieser Fehler. Folgendes ist richtig:

class A {

public:

   virtual myex( int ) = 0;

   virtual twoex( const int ) const = 0;

};

class B : public A {

public:

   myex( int );

   twoex( const int ) const;

};

B b;   // ok


Cannot define a pointer or reference to a reference
Cannot define a pointer or reference to a reference	Compiler-Meldung

Ein Zeiger auf eine Referenz oder eine Referenz auf eine Referenz ist nicht zulässig.


Array of references is not allowed
Array of references is not allowed	Compiler-Meldung

Ein Array aus Referenzen ist nicht zulässig, weil Zeiger auf Referenzen nicht erlaubt sind und Array-Namen in Zeiger umgewandelt werden.


void & is not a valid type
void & is not a valid type	Compiler-Meldung

Eine Referenz bezieht sich immer auf ein Objekt. Ein Objekt kann aber nicht vom Typ void sein.

Darum ist der Typ void hier nicht erlaubt.


'identifier' is not a non-static member and can't be initialized here
'identifier' is not a non-static member and can't be initialized here	Compiler-Meldung

Nur Datenelemente können mit einem Initialisierungswert in einem Konstruktor initialisiert werden.

Hier lag ein statisches Element oder ein Funktionselement vor.

Statische Elemente müssen außerhalb der Klasse initialisiert werden, z.B.:

class A { static int i; };

int A::i = -1;


Destructor for 'class' required in conditional expression
Destructor for 'class' required in conditional expression	Compiler-Meldung

Wenn in einem bedingten Ausdruck der Compiler eine temporäre lokale Variable erzeugen muß, kann der Destruktor eventuell nicht aufgerufen werden, weil die Variable möglicherweise nicht initialisiert ist.

Die temporäre Variable kann explizit mit Klassennamen (val, val) oder implizit mir einem anderen Quelltext erzeugt sein.

Überarbeiten Sie Ihren Quelltext, um die temporäre Variable zu entfernen.


The value for 'identifier' is not within the range of an int
The value for 'identifier' is not within the range of an int	Compiler-Meldung

Alle Aufzählungswerte müssen als Integer dargestellt werden können.

Sie haben versucht, einen Wert außerhalb des Integerbereichs zuzuweisen.

Brauchen Sie eine Konstante mit diesem Wert, verwenden Sie eine konstante Ganzzahl.


Member 'member' cannot be used without an object
Member 'member' cannot be used without an object	Compiler-Meldung

Hier haben Sie Klasse::Element angegeben, und Element ist ein gewöhnliches (nicht statisches), keiner Klasse angehörendes Element.

Dies ist z.B. erlaubt:

obj.Klasse:: Element

Dies dagegen nicht:

Klasse:: Element


Function should return a value (error)
Function should return a value	Compiler-Warnung

(Die Kommandozeilenoption zum Unterdrücken dieser Warnung lautet -w-rvl)

Die Funktion ist so deklariert, daß sie einen anderen Wert als int oder void zurückliefert. Der Compiler hat aber keinen Rückgabewert vorgefunden. Das ist gewöhnlich ein Fehler.

int-Funktionen sind ausgenommen, da es in alten C Versionen keinen void-Typen gab, um anzuzeigen, daß nichts zurückgeliefert wird.


Undefined structure 'structure' (error)
Undefined structure 'structure'	Compiler-Warnung

(Die Kommandozeilenoption zur Anzeige dieser Warnung lautet -wstu)

Die besagte Struktur wird in der Quelldatei angesprochen, wahrscheinlich über einen Zeiger auf eine Struktur, wurde aber vorher nicht definiert.

Der Fehler liegt vermutlich in einem Tippfehler oder einer fehlenden Deklaration.


'base' is an indirect virtual base class of 'class'
'base' is an indirect virtual base class of 'class'	Compiler-Meldung

Sie können in C++ keinen Zeiger auf ein Element einer virtuellen Basisklasse erzeugen.

Sie wollten einen solchen Zeiger (entweder direkt oder durch Typumwandlung) erzeugen und auf ein Element einer Ihrer Basisklassen zugreifen, auf das nicht zugegriffen werden kann.


'identifier' is not a public base class of 'classtype'
'identifier' is not a public base class of 'classtype'	Compiler-Meldung

Der rechte Operand eines Operators .*, -> oder :: muß ein Zeiger auf ein Element einer Klasse sein, die entweder mit der Klasse des linken Operanden identisch oder für diese Klasse zugreifbar ist.


'operator' must be declared with one or no parameters
'operator' must be declared with one or no parameters	Compiler-Meldung

Wenn die Operatoren ++ oder -- als Elementfunktion deklariert werden, müssen sie folgendes übernehmen:

 	Keine Parameter (in der Präfix-Version).

 	Einen Parameter vom Typ int (in der Postfix-Version).


'operator' must be declared with one or two parameters
'operator' must be declared with one or two parameters	Compiler-Meldung

Wenn die Operatoren ++ oder -- als Nicht-Elementfunktion deklariert werden, müssen sie folgendes übernehmen

 	Einen Parameter (in der Präfix-Version).

 	Zwei Parameter (in der Postfix-Version).


'virtual' can only be used with member functions
'virtual' can only be used with member functions	Compiler-Meldung

Ein Datenelement wurde als virtual deklariert.

Nur Elementfunktionen können als virtual deklariert werden.

Zum Beispiel:

class myclass

{

public:

   virtual int a;    //Fehler

};


Address of overloaded function 'function' doesn't match 'type'
Address of overloaded function 'function' doesn't match 'type'	Compiler-Meldung

Einer Variablen oder einem Parameter wurde (evtl. bei der Initialisierung) die Adresse einer überladenen Funktion zugewiesen.

Der Typ der Variablen oder des Parameters paßt jedoch zu keiner der überladenen Funktionen mit dem angegebenen Namen.


Ambiguous member name 'name'
Ambiguous member name 'name'	Compiler-Meldung

Wenn der Name eines Strukturelementes in einer Inline Assembler-Anweisung vorkommt, muß dieser Name eindeutig sein.

(Kommt der Name in mehreren Strukturen vor, dann müssen alle Vorkommen sowohl im Datentyp als auch in der Position innerhalb der Struktur übereinstimmen).

Hier wurde ein nicht eindeutiger Elementname verwendet.

Zum Beispiel:

struct A

{

   int a;

   int b;

};

...

asm ax,.a;


Assignment to 'this' not allowed, use X::operator new instead
Assignment to 'this' not allowed, use X::operator new instead	Compiler-Meldung

In früheren Versionen von C++ war die einzige Möglichkeit, die Speicherbelegung einer Klasse von Objekten zu überwachen, die Zuweisung an den Parameter this innerhalb eines Konstruktors.

Dies ist nicht mehr erlaubt. Eine bessere, sichere und allgemein anwendbare Möglichkeit besteht darin, eine Elementfunktion als new zu definieren.

Zum Beispiel:

this = malloc(n);


Cannot allocate a reference
Cannot allocate a reference	Compiler-Meldung

Sie wollen eine Referenz mittels des Operators new herstellen.

Dies ist nicht erlaubt, weil Referenzen keine Objekte sind und nicht durch new erzeugt werden können.


Cannot call near class member function with a pointer of type 'type'
Cannot call near class member function with a pointer of type 'type'	Compiler-Meldung

Elementfunktionen von near-Klassen können nicht durch einen Elementzeiger aufgerufen werden.

Dies gilt auch für Aufrufe durch Zeiger auf Elemente.

(Wie Sie wissen, sind in den Speichermodellen tiny, small und medium alle Klassen per Voreinstellung near).

Erklären Sie entweder den Zeiger als near oder die Klasse als far.


Cannot convert 'type1' to 'type2'
Cannot convert 'type1' to 'type2'	Compiler-Meldung

Eine Zuweisung, eine Initialisierung oder ein Ausdruck erfordern die besagte Typumwandlung; diese ist jedoch nicht erlaubt.

In C++ konvertiert der Compiler einen Zeiger auf eine Funktion in einen anderen nur dann, wenn die Funktionsköpfe, d.h. Anzahl und Typen der Argumente sowie der Rückgabewerte übereinstimmen. Zum Beispiel:

myex( int );

typedef int ( *ffp )( float );

test()

{

   ffp fp = myex; //Fehler

}

Die Funktion myex hat ein Integer-Argument, fp hingegen ist ein Zeiger auf eine Funktion mit einem Fließkommaargument. Der Compiler nimmt daher die Konvertierung nicht vor.

Für eine Umwandlung muß ein explizite Konversion verwendet werden:

myex( int );

typedef int ( *ffp )( float );

test()

{

   ffp fp = (ffp)myex;  //ok

}


Class 'class' may not contain pure functions
Class 'class' may not contain pure functions	Compiler-Meldung

Die zu deklarierende Klasse kann nicht abstrakt sein, daher kann sie auch keine abstrakte Funktionen enthalten.


Compiler could not generate 'member function' for class 'class'
Compiler could not generate copy constructor for class 'class'	Compiler-Meldung

ODER	Compiler could not generate default constructor for class 'class'

ODER	Compiler could not generate operator = for class 'class'

Manchmal ist es erforderlich, daß der Compiler eine Elementfunktion für den Benutzer erzeugt.

Immer wenn sich dies nicht mit den jeweiligen Sprachregeln vereinbaren läßt, gibt der Compiler eine dieser Meldungen aus.


Constant/Reference member 'member' in class without constructors
Constant/Reference member 'member' in class without constructors	Compiler-Meldung

Eine Klasse, die konstante oder variable Elemente (oder beides) enthält, muß mindestens einen vom Benutzer definierten Konstruktor aufweisen.

Andernfalls gäbe es keine Möglichkeit, solche Elemente zu initialisieren.


Constructor/Destructor cannot be declared 'const' or 'volatile'
Constructor/Destructor cannot be declared 'const' or 'volatile'	Compiler-Meldung

Ein Konstruktor oder ein Destruktor wurde als const oder volatile deklariert.

Dies ist nicht erlaubt.


Default expression may not use local variables
Default expression may not use local variables	Compiler-Meldung

Ein Ausdruck mit voreingestelltem Argument darf sich keiner lokalen Variablen oder anderer Parameter bedienen.


Illegal use of member pointer
Illegal use of member pointer	Compiler-Meldung

Zeiger auf Klassenelemente können nur als Funktionsargument übergeben oder zusammen mit den folgenden Operatoren verwendet werden:

 	Zuweisung

 	Vergleich

 	.*

 	->*

 	?:

 	&&

 	||

Der Compiler entdeckte einen Elementzeiger, der mit einem anderen Operator verwendet wurde.

Um eine Elementfunktion über einen Zeiger aufzurufen, muß eine Instanz der Klasse existieren.

Zum Beispiel:

class A {

public:

   myex();

};

typedef int (A::*Amfptr)();

myex()

{

   Amfptr mmyex = &A::myex;

   (*mmyex)():  //Fehler

}

So ist es richtig:

class A {

public:

   myex();

};

typedef int (A::*Amfptr)();

foo()

{

   A a;

   Amfptr mmyex - &A::myex;

   (a.*mmyex)90;

}


Implicit conversion of 'type1' to 'type2' not allowed
Implicit conversion of 'type1' to 'type2' not allowed	Compiler-Meldung

Wird eine Elementfunktion über einen Zeiger auf eine abgeleitete Klasse aufgerufen, so muß der Zeiger implizit in einen Zeiger auf die entsprechende Basisklasse umgewandelt werden.

In diesem Fall ist diese implizite Umwandlung nicht erlaubt.


Last parameter of 'operator' must have type 'int'
Last parameter of 'operator' must have type 'int'	Compiler-Meldung

Wenn ein Postfix-Operator ++ oder ein Operator -- überladen wird, muß der letzte Parameter mit dem Typ int deklariert sein.


Member function must be called or its address taken
Member function must be called or its address taken	Compiler-Meldung

Eine Referenz auf eine Elementfunktion muß aufgerufen oder ihre Adresse durch den Operator & übernommen werden.

In diesem Fall wurde eine Elementfunktion in einem nicht zulässigen Zusammenhang verwendet.

Zum Beispiel:

class A

{

   void (A::* infptr)(void);

public;

   A();

   void myex(void);

};

A::A()

{

   infptr = myex;   // ungültig - Aufrufen oder Adresse übernehmen?

   infptr = A::& myex;   //richtig

}


Reference initialized with 'type1', needs lvalue of type 'type2'
Reference initialized with 'type1', needs lvalue of type 'type2'	Compiler-Meldung

Eine Referenz-Variable, die nicht als Konstante deklariert ist, muß mit einem L-Wert des entsprechenden Typs initialisiert werden.

In diesem Fall war der Initialisierer entweder kein L-Wert, oder sein Typ paßte nicht zu der zu initialisierenden Referenz.


Only member functions may be 'const' or 'volatile'
Only member functions may be 'const' or 'volatile'	Compiler-Meldung

Etwas anderes als die Elementfunktion einer Klasse wurde als const oder volatile deklariert.


Operand of 'delete' must be non-const pointer
Operand of 'delete' must be non-const pointer	Compiler-Meldung

Die verwendete Variable muß eine Zeigervariable sein.

Es ist nicht erlaubt, einen Zeiger auf eine Konstante zu löschen.

Zum Beispiel:

const int x=10;

   const int * a = &x;

   int * const b = new int;

   int &c = *b;

   delete a;   //unzulässig - Löschen des Zeigers auf eine Konstante

   delete b;   //zulässig

   delete c;   //unzulässig - Operand ist kein Zeiger

               //statt dessen 'delete&c' verwenden


Operator must be declared as function
Operator must be declared as function	Compiler-Meldung

Ein überladener Operator wurde nicht als Funktionstyp deklariert.

Zum Beispiel:

class A

{

   A& operator +;   ..note missing parenthesis

};

In diesem Beispiel fehlen die Klammern (), und der Operator ist somit nicht als Funktion gekennzeichnet.


Operators may not have default argument values
Operators may not have default argument values	Compiler-Meldung

Überladene Operatoren dürfen keine Argumente mit voreingestellten Werten haben.


Overloaded 'function name' ambiguous in this context
Overloaded 'function name' ambiguous in this context	Compiler-Meldung

Ein überladener Funktionsname kann nur dann ohne aktuellen Aufruf der Funktion verwendet werden, wenn eine Variable oder ein Parameter des entsprechenden Funktionszeigertyps initialisiert oder die Adresse der überladenen Funktion zugewiesen wird.

In diesem Fall wurde ein überladener Funktionsname in einem anderen Zusammenhang verwendet. Das folgende Beispiel wird diese Fehlermeldung generieren:

class A{

   A(){myex;}           // Funktionsaufruf

   void myex(int) {}    // oder Adresse?

   void myex(float){}

};


Type mismatch in default argument value
Type mismatch in default argument value	Compiler-Meldung

Der voreingestellte Parameterwert konnte nicht in den Typ des Parameters konvertiert werden.

Diese Meldung wird verwendet, wenn der Parameter nicht benannt wurde.

In C++ erhalten Sie zu dieser Meldung eine weitere, die Ihnen das Problem genauer erklärt.

Sie lautet gewöhnlich "Cannot convert 'type1' to 'type2'" ("Kann Typ1 nicht in Typ2 umwandeln"). Die Gründe für die Typunverträglichkeit können jedoch vielfältiger Natur sein.


Type mismatch in default value for parameter 'parameter'
Type mismatch in default value for parameter 'parameter'	Compiler-Meldung

Der voreingestellte Parameterwert konnte nicht in den Typ des Parameters konvertiert werden.

Die Meldung "Type mismatch in default argument value" wird verwendet, wenn der Parameter nicht benannt wurde.

In C++ erhalten Sie zu dieser Meldung eine weitere, die Ihnen das Problem genauer erklärt.

Sie lautet gewöhnlich "Cannot convert 'type1' to 'type2'" ("Kann Typ1 nicht in Typ2 umwandeln"). Die Gründe für die Typunverträglichkeit können jedoch vielfältiger Natur sein.


union cannot be a base type
union cannot be a base type	Compiler-Meldung

Eine Klasse vom Typ union kann nicht als Basisklasse für einen anderen Klassentyp verwendet werden.


unions cannot have virtual member functions
unions cannot have virtual member functions	Compiler-Meldung

Eine Klasse vom Typ union kann keine virtuellen Funktionen als Elemente enthalten.


Union member 'member' is of type class with constructor/destructor/operator =
Union member 'member' is of type class with constructor (or destructor, or operator =)	Compiler-Meldung

Eine Klasse vom Typ union kann keine Elemente vom Typ einer Klasse mit anwenderdefinierten Konstruktoren, Destruktoren oder den Operator = enthalten.


Use . or -> to call 'member', or & to take its address
Use . or -> to call 'member', or & to take its address	Compiler-Meldung

Es trat eine Referenz auf ein nicht statisches Klassenelement ohne Objekt auf.

Ein derartiges Element kann nur mit Objekt verwendet werden, oder seine Adresse muß durch den Operator & übernommen werden.


Void `function' cannot return a value
Void 'function' cannot return a value	Compiler-Meldung

Eine Funktion mit Rückgabetyp void enthält eine return-Anweisung, die einen Wert zurückliefert, beispielsweise einen int.

Voreinstellung = anzeigen.


'identifier' cannot start a parameter declaration
'identifier' cannot start a parameter declaration	Compiler-Meldung

Ein nicht definierter Bezeichner wurde am Anfang eines Arguments in einer Funktionsdeklaration entdeckt.

Oft ist der Typenname falsch geschrieben oder die Typendeklaration fehlt. Der Grund hierfür ist normalerweise die fehlende Einbindung der entsprechenden Header-Datei.


< expected
< expected	Compiler-Meldung

Dem Schlüsselwort template folgt kein <.

In jeder Template-Deklaration muß nach dem Schlüsselwort template die Liste der formalen Parameter, eingeschlossen in < >, folgen.


Attempting to return a reference to a local object
Attempting to return a reference to a local object	Compiler-Meldung

Sie versuchten, eine Referenz auf ein temporäres Objekt in einer Funktion zurückzugeben, die einen Referenztyp liefert. Dies kann das Ergebnis eines Konstruktors oder eines Funktionsaufrufes sein.

Bei Funktionsende verschwindet dieses Objekt, wodurch die Referenz unzulässig wird.


Base class 'class' contains dynamically dispatchable functions
Base class 'class' contains dynamically dispatchable functions	Compiler-Meldung

Dieser Fehler tritt auf, wenn eine Klasse, die DDVT-Funktionen enthält, versucht, DDVT-Funktionen von mehrfach übergeordneten Klassen zu erben.

Derzeit wird die Verwendung von Mehrfachvererbung durch dynamisch zugeordnete virtuelle Tabellen nicht unterstützt.


Bit fields must be signed or unsigned int (error)
Bit fields must be signed or unsigned int	Compiler-Meldung

In ANSI C können Bit-Felder nur vom Typ signed oder unsigned int sein (z.B. nicht char oder long).


Cannot add or subtract relocatable symbols
Cannot add or subtract relocatable symbols	Compiler-Meldung

Die einzige ausführbare arithmetische Operation auf ein relozierbares Symbol in einem Assembler-Operanden ist die Addition oder Subtraktion einer Konstanten.

Relozierbare Symbole sind Prozeduren, Funktionen und Labels.


Cannot have a non-inline function/static data in a local class
Cannot have a non-inline function/static data in a local class	Compiler-Meldung

Alle zu einer Funktion lokal deklarierten Elemente einer Klasse müssen vollständig in der Definition der Klasse deklariert sein.

Dies bedeutet, daß lokale Klassen keine statischen Datenelemente enthalten können, und die Funktionsrümpfe all ihrer Elementfunktionen innerhalb der Definition der Klasse deklariert sein müssen.


Case bypasses initialization of a local variable
Case bypasses initialization of a local variable	Compiler-Meldung

Es ist in C++ nicht zulässig, die Initialisierung einer lokalen Variable zu umgehen.

Dieser Fehler deutet auf ein case-Label hin, welches die Steuerung hinter diese lokale Variable transferiert.


Declaration does not specify a tag or an identifier
Declaration does not specify a tag or an identifier	Compiler-Meldung

Diese Deklaration deklariert gar nichts.

Sie haben vielleicht eine Struktur oder eine Union ohne Benennung oder ohne Variablen deklariert. C++ verlangt, daß etwas deklariert wird.

Zum Beispiel:

struct

{

int a

};

// kein Bezeichner


Expression of scalar type expected
Expression of scalar type expected	Compiler-Meldung

Die Operatoren !, ++, und -- verlangen einen skalaren Ausdruck.

Lediglich diese Typen sind erlaubt:

char

 	short

 	int

 	long

 	enum

 	float

 	double

 	long double

 	pointer


Extra argument in template class name 'template'
Extra argument in template class name 'template'	Compiler-Meldung

Der Klassenname eines Template gab zu viele aktuelle Werte für ihre formalen Parameter an.


Function definition cannot be a typedef'ed declaration
Function definition cannot be a typedef'ed declaration	Compiler-Meldung

In ANSI C darf ein Funktionsrumpf nicht unter Verwendung eines typedef mit einem Funktionstypen definiert werden.

Definieren Sie den Funktionsrumpf neu.


Functions 'function1' and 'function2' both use the same dispatch number
Functions 'function1' and 'function2' both use the same dispatch number	Compiler-Meldung

Dieser Fehler deutet auf ein Problem mit einer dynamisch zugeordneten, virtuellen Tabelle hin (DDVT).


Goto bypasses initialization of a local variable
Goto bypasses initialization of a local variable	Compiler-Meldung

Es ist in C++ nicht zulässig, die Initialisierung einer lokalen Variable zu umgehen.

Dieser Fehler deutet auf eine goto-Anweisung hin, welche die Steuerung hinter diese lokale Variable transferiert.


Illegal parameter to __emit__
Illegal parameter to _ _emit_ _	Compiler-Meldung

Beim direkten Einfügen von Literalen in Ihr Programm mit der Funktion __emit__ gibt es einige Einschränkungen.

Sie können beispielsweise eine lokale Variable nicht als Parameter an __emit__ übergeben.


Invalid combination of opcode and operands
Invalid combination of opcode and operands	Compiler-Meldung

Der integrierte Assembler akzeptiert diese Kombination von Operanden nicht.

Mögliche Ursachen

 	Es sind zu viele oder zu wenige Operanden für diesen Assembler Opcode vorhanden.

 	Die Anzahl der Operanden ist korrekt, aber ihr Typ oder ihre Reihenfolge stimmt nicht mit dem Opcode überein.


Invalid register combination (e.g. [BP+BX])
Invalid register combination (e.g. [BP+BX])	Compiler-Meldung

Der integrierte Assembler hat eine nicht zulässige Kombination von Registern innerhalb einer Anweisung gefunden.

Zulässige Index-Registerkombinationen sind:

[BX]

 	[BP]

 	[SI]

 	[DI]

 	[BX+SI]

 	[BX+DI]

 	[BP+SI]

 	[BP+DI]

Other index register combinations are not allowed. Andere Index-Registerkombinationen sind nicht erlaubt.


Invalid template argument list
Invalid template argument list	Compiler-Meldung

Dieser Fehler deutet darauf hin, daß eine nicht zulässige Argumentliste in einer Template-Deklaration gefunden wurde.

Dem Schlüsselwort template muß in der Deklaration eine Liste formaler Argumente innerhalb der Begrenzer < und > folgen.


Invalid template qualified name 'template::name'
Invalid template qualified name 'template::name'	Compiler-Meldung

Bei der Template-Definition eines Klassenelements muß das als linker Operand für den Operator :: verwendete aktuelle Argument des Template-Klassennamens mit dem formalen Argument der Template-Klasse übereinstimmen.


Invalid use of template 'template'
Invalid use of template 'template'	Compiler-Meldung

Der Klassenname eines Template kann nur verwendet werden, wenn die aktuellen Argumente in der Template-Definition nicht spezifiziert werden.

Es ist nicht zulässig, den Template-Klassennamen zu verwenden, ohne die aktuellen Argumente außerhalb der Template-Definition zu spezifizieren.


Matching base class function 'function' has different dispatch number
Matching base class function 'function' has different dispatch number	Compiler-Meldung

Ist eine DDVT-Funktion in einer abgeleiteten Klasse deklariert, so muß die entsprechende Funktion der Basisklasse dieselbe Zuordnungsnummer wie die abgeleitete Funktion haben.


Matching base class function 'function' is not dynamic
Matching base class function 'function' is not dynamic	Compiler-Meldung

Ist eine DDVT-Funktion in einer abgeleiteten Klasse deklariert, so muß die entsprechende Basisklassenfunktion ebenfalls dynamisch sein.


Member 'member' has the same name as its class
Member 'member' has the same name as its class	Compiler-Meldung

Ein statisches Datenelement, ein Zählwert, ein Element einer anonymen Variante oder ein verschachtelter Typ können nicht denselben Namen wie ihre Klasse haben.

Lediglich eine Elementfunktion oder ein nicht statisches Element können einen mit ihrer Klasse übereinstimmenden Namen haben.


Memory reference expected
Memory reference expected	Compiler-Meldung

Der integrierte Assembler verlangt eine Speicherreferenz.

Sie haben wahrscheinlich vergessen, einen Index-Registeroperanden in eckige Klammern zu setzen.


Nontype template argument must be of scalar type
Nontype template argument must be of scalar type	Compiler-Meldung

Ein typenloses, formales Template-Argument muß von skalarem Typ sein, es kann ein Ganzzahl-, Aufzählungs- oder Zeigertyp sein.


operator new must have an initial parameter of type size_t

Operator new[] Must Have an Initial Parameter of Type size_t	Compiler-Meldung

Der Operator new kann mit einer beliebigen Parameteranzahl deklariert werden.

Allerdings muß er wenigstens einen Parameter besitzen, und zwar die zu reservierende Speichergröße.


Template argument must be a constant expression
Template argument must be a constant expression	Compiler-Meldung

Ein typenloses Template-Klassenargument muß einen konstanten Ausdruck des entsprechenden Typs darstellen.

Dies beinhaltet konstante, ganzzahlige Ausdrücke und Adressen von Objekten oder Funktionen mit externer Bindung oder externen Elementen.


Template class nesting too deep: 'class'
Template class nesting too deep: 'class'	Compiler-Meldung

Der Compiler schränkt die Tiefe der Verschachtelung von Template-Klassen ein. Diese Einschränkung wird normalerweise nur überschritten, wenn zwischen den Template-Klassen rekursive Abhängigkeiten bestehen.

Wird diese Einschränkung überschritten, so gibt der Compiler für jede der verschachtelten Template-Klassen eine Fehlermeldung aus. Dies vereinfacht normalerweise die Auflösung der Rekursion.

Auf diese Fehlermeldung folgt immer der sofortige Abbruch: "Out of memory"


Template functions may only have 'type-arguments'
Template functions may only have 'type-arguments'	Compiler-Meldung

Bei der Deklaration einer Template-Funktion wurde ein Argument verwendet, das nicht mit type eingeleitet wurde.

Dies ist bei einer Template-Funktion nicht erlaubt, da der Wert bei einem Aufruf nicht angegeben werden kann.


Template function argument 'argument' not used in argument types
Template function argument 'argument' not used in argument types	Compiler-Meldung

Das gegebene Argument wurde nicht in der Argumentliste der Funktion verwendet.

Die Argumentliste einer Template-Funktion muß alle formalen Argumente des Templates umfassen. Ansonsten ist es nicht möglich, eine auf aktuellen Argumententypen basierende Instanz einer Template-Funktion zu generieren.


Templates can only be declared at file level
Templates can only be declared at file level	Compiler-Meldung

Templates können nicht innerhalb von Klassen oder Funktionen deklariert werden.

Sie sind nur im globalen Gültigkeitsbereich oder auf Dateiebene erlaubt.

Zum Beispiel:

template <class T, class U>

void foo(Ta,Tb)

{

   .

   .

   .

}

// Fehler, U wird nicht benutzt


Templates must be classes or functions
Templates must be classes or functions	Compiler-Meldung

Eine Template-Deklaration muß entweder den Typ einer Klasse oder eine Funktion angeben.


The constructor 'constructor' is not allowed
The constructor 'constructor' is not allowed	Compiler-Meldung

Konstruktoren der Form

X::(X)

sind nicht erlaubt.

Die richtige Schreibweise eines Kopierkonstruktors ist:

X::(const X&).


Too few arguments in template class name 'template'
Too few arguments in template class name 'template'	Compiler-Meldung

Dem Namen einer Template-Klasse fehlen aktuelle Werte für einige der formalen Parameter


Trying to derive a far class from the huge base 'base'
Trying to derive a far class from the huge base 'base'	Compiler-Meldung

Ist eine Klasse (eventuell per Voreinstellung) als huge deklariert, müssen alle abgeleiteten Klassen ebenfalls huge sein.


Trying to derive a huge class from the far base 'base'
Trying to derive a huge class from the far base 'base'	Compiler-Meldung

Ist eine Klasse (eventuell per Voreinstellung) als far deklariert, müssen alle abgeleiteten Klassen ebenfalls far sein.


Trying to derive a huge class from the near base 'base'
Trying to derive a huge class from the near base 'base'	Compiler-Meldung

Ist eine Klasse (eventuell per Voreinstellung) als near deklariert, müssen alle abgeleiteten Klassen ebenfalls near sein.


Trying to derive a near class from the huge base 'base'
Trying to derive a near class from the huge base 'base'	Compiler-Meldung

Ist eine Klasse (eventuell per Voreinstellung) als far deklariert, müssen alle abgeleiteten Klassen ebenfalls far sein.


Type mismatch in parameter 'parameter' in template class name 'template'
Type mismatch in parameter 'parameter' in template class name 'template'	Compiler-Meldung

Der für den Parameter angegebene Wert des Template-Arguments stimmt nicht vollständig mit dem Typen des formalen Template-Parameters überein.

In C++ erhalten Sie zu dieser Meldung eine weitere, die Ihnen das Problem genauer erklärt.

Sie lautet gewöhnlich "Cannot convert 'type1' to 'type2'" ("Kann Typ1 nicht in Typ2 umwandeln"). Die Gründe für die Typunverträglichkeit können jedoch vielfältiger Natur sein.


Type mismatch in parameter 'number' in template class name 'template'
Type mismatch in parameter 'number' in template class name 'template'	Compiler-Meldung

Der für den Parameter angegebene Wert des Template-Arguments stimmt nicht vollständig mit dem Typen des formalen Template-Parameters überein.

In C++ erhalten Sie zu dieser Meldung eine weitere Meldung, die Ihnen das Problem genauer erklärt.

Sie lautet gewöhnlich "Cannot convert 'type1' to 'type2'" ("Kann Typ1 nicht in Typ2 umwandeln"). Die Gründe für die Typunverträglichkeit können jedoch vielfältiger Natur sein.


Bit fields must have integral type
Bit fields must have integral type	Compiler-Meldung

In C++ müssen Bitfelder ein Integertyp sein. Dies gilt auch für Aufzählungen.


Cannot find default constructor to initialize array element of type 'class'
Cannot find default constructor to initialize array element of type 'class'	Compiler-Meldung

Bei der Deklaration eines Arrays über eine Klasse, die Konstruktoren besitzt, müssen Sie entweder jedes einzelne Element im Array explizit initialisieren oder die Klasse muß über einen Standardkonstruktor verfügen.

Solange Sie für die Klasse keinen Konstruktor definiert haben, stellt der Compiler einen Standardkonstruktor bereit.


Cannot generate 'function' from template function 'template'
Cannot generate 'function' from template function 'template'	Compiler-Meldung

Es liegt ein Aufruf einer Template-Funktion vor, aus dem Funktions-Template kann aber keine entsprechende Template-Funktion erzeugt werden.


Variable 'variable' has been optimized and is not available
Variable 'variable' has been optimized and is not available	Compiler-Meldung

Sie versuchen, eine vom Optimierungsprogramm entfernte Variable zu untersuchen, zu überwachen oder auf diese zuzugreifen.

Dieser Variablen ist kein Wert zugewiesen, und sie liegt nicht auf dem Stack.


Function should return a value (warning)
Function should return a value	Compiler-Meldung

Diese Funktion sollte laut Deklaration (möglicherweise implizit) einen Wert zurückliefern.

Der Compiler hat eine return-Anweisung ohne zugehörigen Rückgabewert gefunden, oder er hat das Ende der Funktion erreicht, ohne eine return-Anweisung vorzufinden.

Geben Sie entweder einen Wert zurück, oder ändern Sie die Funktionsdeklaration in void um.


Undefined structure 'structure' (warning)
Undefined structure 'structure'	Compiler-Meldung

In Ihrer Quelltextdatei wird die angegebene Struktur einige Zeilen vor dem ausgewiesenen Fehler verwendet (eventuell in einem Zeiger auf eine Struktur), ohne vorher definiert worden zu sein.

Entweder enthält der Strukturname einen Tippfehler oder es fehlt die Deklaration.


Call to function 'function' with no prototype
Call to function 'function' with no prototype	Compiler-Meldung

Diese Warnung erhalten Sie nach Aktivierung von Prototypes required , wenn Sie die Funktion Funktion aufrufen, ohne zuvor einen Prototypen für diese Funktion angegeben zu haben.


Initializing 'identifier' with 'identifier'
Initializing 'identifier' with 'identifier'	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-bei)

Sie versuchen, eine enum-Variable mit einem falschen Typen zu initialisieren.

Folgende Initialisierung führt beispielsweise zu dieser Warnung, da 2 vom Typ int und nicht vom Typ enum count ist:

enum count zero, one, two x = 2;

Es entspricht besserem Programmierstil, bei der Zuweisung oder Initialisierung von Aufzählungstypen anstatt eines Integer-Literals einen enum-Bezeichner zu verwenden.

Dies ist ein Fehler, der jedoch auf eine Warnung reduziert wurde, damit bestehende Programme ablaufen können.


Initialization is only partially bracketed
Initialization is only partially bracketed	Compiler-Warnung

(Die Kommandozeilenoption zur Anzeige dieser Warnung lautet -wpin)

Bei der Initialisierung von Strukturen können Klammern verwendet werden, um die Initialisierung eines jeden Elements der Struktur zu markieren.

Ist ein Element selbst ein Array oder eine Struktur, können verschachtelte Klammern verwendet werden.

Dies stellt sicher, daß der Compiler jeden Wert dem von Ihnen gewünschten Element zuordnet.

Der Compiler gibt diese Warnung aus, wenn optionale Klammern weggelassen werden.


'identifier' is declared as both external and static
'identifier' is declared as both external and static	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-ext)

Dieser Bezeichner trat in einer Deklaration auf, die ihn als implizit oder explizit sowohl als global oder extern als auch als static kennzeichnete.

Der Bezeichner gilt jetzt als static.

Sie sollten alle Deklarationen für diesen Bezeichner überprüfen.


Declare 'type' prior to use in prototype
Declare 'type' prior to use in prototype	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-dpu)

Wenn sich ein Funktionsprototyp auf einen Strukturtypen bezieht, der nicht zuvor deklariert wurde, ist die Deklaration innerhalb und außerhalb des Prototypen nicht identisch.

Zum Beispiel:

int func(struct s *ps);  struct s   /* ... */ ;

Da beim Prototypen func der Gültigkeitsbereich von struct s nicht bekannt ist, ist der Typ des Parameters ps ein Zeiger auf ein nicht definiertes struct s und damit nicht derselbe wie das später deklarierte struct s.

Dies führt später zu mysteriösen Warnungen und Fehlermeldungen bezüglich inkompatibler Typen, die ohne diese Warnung kaum erklärbar wären.

Zur Lösung des Problems sollte die Deklaration von struct s vor jedem Prototypen stehen, der sich auf sie bezieht, oder die unvollständige Typendeklaration struct s; vor jeden Prototypen, der sich auf struct s bezieht. Ist der Funktionsparameter eine Struktur anstatt eines Zeigers auf eine Struktur, reicht die unvollständige Deklaration nicht aus.

Die Deklaration der Struktur muß dann vor dem Prototypen stehen.


Division by zero (warning)
Division by zero	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-zdi)

Ein Divisions- oder Restausdruck hatte Null als Divisor.


Ambiguous operators need parentheses
Ambiguous operators need parentheses	Compiler-Warnung

(Die Kommandozeilenoption zur Anzeige dieser Warnung lautet = -wamb)

Diese Warnung erhalten Sie bei der Kombination von relationalen, bitweisen oder Schiebe-Operatoren ohne Klammerung.

Bei der Kombination eines Additions- oder Subtraktionsoperators mit einem Schiebeoperator ohne Klammerung wird auch diese Warnung erzeugen.


Superfluous & with function
Superfluous & with function	Compiler-Warnung

(Die Kommandozeilenoption zur Anzeige dieser Warnung lautet -wamp)

Ein Adreßoperator (&) ist bei einem Funktionsnamen nicht notwendig, derartige Operatoren werden verworfen.


Parameter 'parameter' is never used
Parameter 'parameter' is never used	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-par)

Ein bei der Deklaration der Funktion angegebener Parameter wird innerhalb der Funktion nicht verwendet.

Dies kann ein Fehler sein, wird jedoch oft durch falsche Schreibweise des Parameters verursacht.

Diese Warnung kann auch auftreten, wenn der Bezeichner im Rumpf einer Funktion erneut als automatische (lokale) Variable deklariert wird.

Der Parameter wird von der automatischen Variable überdeckt und nicht verwendet.


Restarting compile using assembly
Restarting compile using assembly	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-asc)

Der Compiler hat eine asm -Anweisung ohne Entsprechung oder Inline-Anweisung #pragma vorgefunden.

Die Compilierung wird unter Verwendung der Assembler-Sprachfähigkeiten neu gestartet.

Voreinstellung = Ein


Unknown assembler instruction
Unknown assembler instruction	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-asm)

Der Compiler hat eine Inline-Assembler-Anweisung gefunden, die einen unzulässigen Opcode enthält.

Überprüfen Sie die Schreibweise des Opcodes.

Die Kommandozeilenoption -wasm dient zur Kontrolle der Warnung.

Voreinstellung = nicht anzeigen.


Hexadecimal value contains more than 3 digits
Hexadecimal value contains more than three digits	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-big)

In älteren C Versionen konnten hexadezimale Escape-Sequenzen nicht mehr als drei Stellen lang sein.

Der ANSI-Standard erlaubt beliebig viele Stellen, solange der Wert noch in ein Byte paßt.

Diese Warnung erscheint bei einer langen hexadezimalen Escape-Sequenz mit vielen führenden Nullen (z.B. \x00045).

Ältere C Versionen interpretieren diesen String anders.


Constant is long
Constant is long	Compiler-Warnung

(Die Kommandozeilenoption zur Anzeige dieser Warnung lautet -wcln)

Der Compiler hat einen der folgenden Werte gefunden:

 	Eine Dezimalkonstante, die größer als 32.767 ist.

 	Eine Oktal-, Hexadezimal- oder Dezimalkonstante ohne den Zusatz L oder l, die größer als 65.535 ist.

Die Konstante wird als Konstante vom Typ long behandelt.


Nonportable pointer comparison (warning)
Non-portable pointer comparison	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-cpt)

Ihr Quelltext enthält einen Vergleich von einem Zeiger mit einem Nicht-Zeiger (der nicht die Konstante 0 ist).

Verwenden Sie eine Umwandlung, wenn Sie diese Warnung unterdrücken wollen und der Vergleich korrekt ist.


Temporary used to initialize 'identifier'
Temporary used to initialize 'identifier'	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-lin)

In C++ müssen sich Referenzvariablen oder -parameter auf ein Objekt desselben Typs beziehen.

Stimmen die Typen nicht überein, findet eine Zuweisung des aktuellen Wertes an eine temporäre Größe desselben Typs statt. Die Adresse der temporären Größe wird der Referenzvariablen oder dem Referenzparameter zugewiesen.

Die Warnung zeigt, daß die Referenzvariable oder der Referenzparameter nicht auf das Erwartete, sondern auf eine temporäre Variable verweist, die sonst nicht verwendet wird.

Siehe auch

Beispiel


Example for "Temporary used ..." error messages
Example for "Temporary used ..." error messages	Compiler-Meldung

Hier braucht eine Funktion f eine Referenz auf ein int, wobei c jedoch ein char ist:

f(int&);

char c;

f(c);

Anstatt f mit der Adresse von c aufzurufen, generiert der Compiler Code, der folgendem C++ Quelltext entspricht::

int X = c, f(X);


Temporary used for parameter 'parameter'
Temporary used for parameter 'parameter'	Compiler-Warnung

ODER	Temporary used for parameter 'number'

ODER	Temporary used for parameter 'parameter' in call to 'function'

ODER	Temporary used for parameter 'number' in call to 'function'

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet = -w-lvc)

In C++ müssen sich Referenzvariablen oder -parameter auf ein Objekt desselben Typs beziehen.

Stimmen die Typen nicht überein, findet eine Zuweisung des aktuellen Wertes an eine temporäre Größe desselben Typs statt. Die Adresse der temporären Größe wird der Referenzvariable oder dem Referenzparameter zugewiesen.

Die Warnung zeigt, daß die Referenzvariable oder der Referenzparameter nicht auf das Erwartete, sondern auf eine temporäre Variable verweist, die sonst nicht benutzt wird.


The constant member 'member' is not initialized
The constant member 'identifier' is not initialized	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-nci)

Diese C++ Klasse enthält ein konstantes Element Element, das nicht initialisiert wurde.

Beachten Sie, daß konstante Elemente nur initialisiert werden dürfen. Ihnen kann nichts zugewiesen werden.


Functions containing reserved words are not expanded inline
Functions containing reserved words are not expanded inline	Compiler-Warnung

Auch:

Functions containing local destructors are not expanded inline in function 'function'

(Die Kommandozeilenoption zur Anzeige dieser Warnung lautet -w-inl)

Reservierte Wörter

Funktionen, in denen die hier genannten reservierten Wörter vorkommen, können nicht als Inline-Funktionen expandiert werden, selbst wenn sie als solche angegeben sind:

 	break

 	case

 	continue

 	do

 	for

 	goto

 	switch

 	while

Die Funktion ist immer noch zulässig, wird jedoch static (nicht global) behandelt.

Eine Kopie dieser Funktion erscheint in jeder Compilierungseinheit, in der sie aufgerufen wird.

Lokale Destruktoren:

Sie haben eine Inline-Funktion erstellt, für die durch den Compiler inline außer Kraft gesetzt ist. Sie können diese Warnung übergehen, die Funktion wird ohne inline generiert.


Base initialization without a class name is now obsolete
Base initialization without a class name is now obsolete	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-obi)

Frühere Versionen von C++ initialisierten eine Basisklasse, indem auf den Kopf des Konstruktors lediglich die Parameterliste des Konstruktors der Basisklasse folgte.

Jetzt sollte der Name der Basisklasse mit eingebunden werden.

Dadurch wird der Quelltext lesbarer, was bei mehrfachen Basisklassen auch notwendig wird.

Früher

abgeleitet::abgeleitet(int i) : (i, 10) { ... }

Jetzt

abgeleitet::abgeleitet(int i) : base(i, 10) { ... }


Style of function definition is now obsolete
Style of function definition is now obsolete	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-ofp)

Dieser veraltete Stil einer Funktionsdefinition ist in C++ nicht mehr zulässig:

int func(p1, p2) int p1, p2; { /* ... */ }

Auch andere C++ Compiler erlauben dies möglicherweise nicht.


'overload' is now unnecessary and obsolete
Overload is now unnecessary and obsolete	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-ovl)

Frühere Versionen von C++ benötigten das Schlüsselwort overload zur Kennzeichnung überladener Funktionsnamen.

Inzwischen verwendet C++ "typensichere Bindung", wobei alle Funktionen als überladenen angenommen werden, solange sie nicht anders gekennzeichnet werden.

overload sollte nicht weiter verwendet werden.


Assigning 'type' to 'enumeration'
Assigning 'type' to 'enumeration'	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-eas)

Ein Integerwert wurde dem Typ enum zugewiesen.

Dies ist in C++ ein Fehler, der jedoch auf eine Warnung reduziert wurde, um bereits bestehende Programme ablaufen lassen zu können.

Voreinstellung = anzeigen.


Non-constant function 'function' called for constant object
Non-const function 'function' called for const object	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-cnf)

Eine nicht konstante Elementfunktion wurde für ein konstantes Objekt aufgerufen.

(Dies ist ein Fehler, der jedoch auf eine Warnung reduziert wurde, um bereits bestehende Programme ablaufen lassen zu können.)


Non-volatile function 'function' called for volatile object
Non-volatile function 'function' called for volatile object	Compiler-Meldung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-nvf)

In C++ wurde eine Elementfunktion einer Klasse für ein Objekt vom Typ volatile aufgerufen, aber die Funktion war nicht mit volatile nach dem Funktionskopf gekennzeichnet. Nur explizit als volatile deklarierte Elementfunktionen können mit Objekten vom Typ volatile aufgerufen werden.

Bei folgendem Beispiel

class c

  {

  public:

    f() volatile;

    g();

  };

  volatile c vcvar;

ist es zulässig, vcvar.f() aufzurufen, nicht jedoch vcvar.g().


'function1' hides virtual function 'function2'
'function1' hides virtual function 'function2'	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-hid)

Eine virtuelle Funktion wird üblicherweise von der Deklaration einer abgeleiteten Klasse überschrieben.

In diesem Fall ist weiteren abgeleiteten Funktionen durch eine Deklaration mit demselben Namen, aber mit unterschiedlichen Argumententypen, der Zugriff auf die virtuellen Funktionen nicht mehr möglich.


Possible use of 'identifier' before definition
Possible use of 'identifier' before definition	Compiler-Warnung

(Die Kommandozeilenoption zur Anzeige dieser Warnung lautet -wdef)

In Ihrer Quelltextdatei wurde die Variable Bezeichner in einem Ausdruck verwendet, bevor eine Wertzuweisung stattfand.

Der Compiler führt eine einfache Programmüberprüfung durch, um diese Fehlerquelle zu finden.

Diese Warnung wird generiert, wenn eine Variable physikalisch vor jeglicher Wertzuweisung auftritt.

Selbstverständlich kann im aktuellen Programmfluß eine Wertzuweisung erfolgen, bevor diese vom Programm verwendet wird.


Constant out of range in comparison
Constant out of range in comparison	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-rng)

Ihre Quelltextdatei enthält einen Vergleich, der eine Teilbereichskonstante betrifft, die außerhalb des Bereichs der anderen Konstante liegt.

So ergibt z.B. der Vergleich eines unsigned-Typs mit -1 keinen Sinn.

Um eine unsigned-Konstante zu erhalten, die größer als 32.767 (dezimal) ist, haben Sie die folgenden Möglichkeiten:

 	Für unsigned eine Typumwandlung durchführen, z.B. (unsigned) 65535.

 	Den Buchstaben u oder U an die Konstante anfügen, z.B. 65535u.

Trotz dieser Meldung wird der Compiler Code generieren, um den Vergleich durchzuführen.

Auch wenn der Code letztendlich immer dasselbe Resultat liefert (weil z.B. ein Ausdruck vom Typ char mit 4000 verglichen wird), wird der Code den Test doch immer wieder durchführen.


Redefinition of 'macro' is not identical
Redefinition of 'macro' is not identical	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-dup)

Ihre Quelltextdatei definiert das Makro Makro neu mit einem Text, der nicht vollständig mit der ersten Definition des Makros übereinstimmt.

Der alte Text wird durch den neuen ersetzt.


Array variable 'identifier' is near
Array variable 'identifier' is near	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-ias)

Bei Setzen der Option Schwellenwert für Far-Daten definiert der Compiler globale Variablen, die größer als der Schwellenwert sind, automatisch als far.

Ist die Variable ein initialisiertes Array von unbekannter Größe, dann ist dem Compiler die Gesamtgröße nicht bekannt, falls er über die Verwendung von near oder far entscheiden muß. In diesem Fall wird near angenommen.

Der Compiler gibt diese Warnung aus, wenn durch die Anzahl der für das Array gegebenen Initialisierer die Gesamtgröße der Variablen die Schwellengröße überschreitet.

Erklären Sie betreffende Variablen explizit als far, falls durch die Festlegung der Variablen durch den Compiler als near Probleme auftreten.

Dazu fügen Sie das Schlüsselwort far unmittelbar vor dem Variablennamen in der Definition ein.


Possibly incorrect assignment
Possibly incorrect assignment	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-pia)

Diese Warnung erhalten Sie, wenn der Compiler einen Zuweisungsoperator als Hauptoperator eines bedingten Ausdrucks (Teil einer if, while- oder do-while-Anweisung) antrifft.

Diese Warnung wird häufig von einem typographischen Fehler im Gleichheitsoperator ausgelöst.

Um die Warnung zu unterdrücken, schreiben Sie die Zuweisung in runde Klammern und vergleichen den gesamten Ausdruck explizit mit Null.

Beispielsweise sollte diese Programmzeile:

if (a = b) ...

so umgeschrieben werden:

if ((a = b) != 0) ...


Conversion may lose significant digits
Conversion may lose significant digits	Compiler-Warnung

(Die Kommandozeilenoption zur Anzeige dieser Warnung lautet -wsig)

Für einen Zuweisungsoperator oder Ähnliches erfordert Ihre Quelltextdatei möglicherweise eine Konvertierung vom Typ long oder unsigned long nach int oder unsigned int.

Da Variablen vom Typ long und int nicht dieselbe Größe haben, könnte diese Konvertierung das Verhalten eines Programms verändern.


No declaration for function 'function'
No declaration for function 'function'	Compiler-Warnung

(Die Kommandozeilenoption zur Anzeige dieser Warnung lautet -wnod)

Diese Warnung erhalten Sie, wenn Sie eine Funktion aufrufen, ohne diese vorher deklariert zu haben.

In C kann eine Funktion ohne Prototyp deklariert werden, z.B.

int func();

In C++ stellt jede Funktionsdefinition auch einen Prototypen dar, das Beispiel ist äquivalent zu

int func(void);

Die Deklaration kann hier im klassischen oder modernen (Prototyp) Stil erfolgen


Code has no effect
Code has no effect	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-eff)

Diese Warnung erhalten Sie, wenn der Compiler auf eine Anweisung mit Operatoren trifft, die keine Auswirkungen haben.

Beispielsweise hat folgende Anweisung

a + b;

keine Auswirkung auf eine der beiden Variablen.

Die Operation ist nicht erforderlich und weist wahrscheinlich auf einen Fehler hin.


'identifier' is assigned a value that is never used
'identifier' is assigned a value that is never used	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-aus)

Die Variable erscheint in einer Zuweisung, wird jedoch in der eben endenden Funktion nirgendwo mehr verwendet.

Die Warnung erscheint nur, wenn der Compiler auf die abschließende Klammer trifft.


Ill-formed pragma
Ill-formed pragma	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -will)

Dieses Pragma entspricht keinem, das der Compiler erwartete.


Call to function with no prototype
Call to function with no prototype	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -wpro)

Diese Warnung erhalten Sie, wenn "Prototypes required" aktiviert ist und eine Funktion aufgerufen wird, für die vorher noch kein Protoytyp angegeben wurde.


Suspicious pointer conversion
Suspicious pointer conversion	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-sus)

Der Compiler hat eine Zeiger-Umwandlung gefunden, die den Zeiger auf einen unterschiedlichen Typ zeigen läßt.

Sie sollten eine Umwandlung durchführen, um die Warnung zu unterdrücken, wenn die Umwandlung tatsächlich richtig ist.

Ein häufiger Grund für diese Warnung ist die Umwandlung eines Funktionszeigers von einem Typ auf einen anderen (In C++ wird in diesem Fall eine Fehlermeldung erzeugt). Diese Fehlermeldung kann durch eine Typumwandlung vermieden werden. Hier ein Beispiel für Windows-Programmierer

#define STRICT

#include <windows.h>

LPARAM _export WndProc( HWND , UINT , WPARAM , LPARAM );

test() {

   WNDCLASS wc;

   wc.lpfnWndProc = WndProc;  //Warnung

}

Folgende Zuweisung an lpfnWndProc unterdrückt die Warnung:

wc.lpfnWndProc = ( WNDPROC ) WndProc;


Unreachable code
Unreachable code	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-rch)

Nach einer break-, continue-, goto- oder return-Anweisung folgt kein Label oder kein Ende einer Schleife oder Funktion.

Der Compiler überprüft while-, do- und for-Schleifen mit einer konstanten Testbedingung und versucht Schleifen festzustellen, die nie durchlaufen werden.


Both return and return with a value used
Both return and return of a value used	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-ret)

Die aktuelle Funktion hat return-Anweisungen mit und ohne Werte.

Das ist in C zulässig, resultiert aber meistens aus einen Programmierfehler.

Möglicherweise wurde eine return-Anweisung am Ende der Funktion vergessen.


Nonportable pointer conversion
Nonportable pointer conversion	Compiler-Meldung

Ein von Null verschiedener ganzzahliger Wert wird in einem Zusammenhang verwendet, in dem ein Zeiger oder ein ganzzahliger Wert erforderlich ist; Größe von Ganzzahltyp und Zeiger sind gleich.

Verwenden Sie eine explizite Umwandlung, wenn Sie dies wirklich wollen.


Void functions may not return a value
Void functions may not return a value	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-voi)

Ihre Quelltextdatei deklarierte den Rückgabewert der aktuellen Funktion als void, der Compiler fand jedoch eine return-Anweisung mit einem Wert.

Der Wert der return-Anweisung wird ignoriert.


Structure passed by value
Structure passed by value	Compiler-Warnung

(Die Kommandozeilenoption zur Anzeige dieser Warnung lautet -wstv)

Diese Warnung wird erzeugt, wenn eine Struktur über ihren Wert als Argument übergeben wird.

Es ist ein häufiger Programmierfehler, einen AdreßOperator (&) vor einer Struktur zu belassen, wenn diese als Argument übergeben wird.

Diese Unterlassung ist jedoch akzeptabel, da Strukturen über ihren Wert übergeben werden können.

Diese Meldung ermöglicht dem Compiler, Sie vor diesem Fehler zu warnen.


Mixing pointers to signed and unsigned char
Mixing pointers to different 'char' types	Compiler-Warnung

(Die Kommandozeilenoption zur Anzeige dieser Warnung lautet -wucp)

Sie führten die Umwandlung von einem Zeiger auf signed in unsigned char oder umgekehrt ohne Angabe einer expliziten Typumwandlung durch. (Genau genommen ist dies nicht zulässig, oft jedoch ohne Bedeutung.)


'identifier' is declared but never used
'identifier' is declared but never used	Compiler-Warnung

(Die Kommandozeilenoption zur Anzeige dieser Warnung lautet -wuse)

Diese Meldung kann bei lokalen oder statischen Variablen erscheinen. Dies geschieht, wenn in der Quelldatei die genannte lokale oder statische Variable im gerade endenden Block deklariert, aber darin nie verwendet worden ist.

Bei lokalen Variablen erscheint diese Warnung, wenn der Compiler auf die abschließende Klammer der zusammengesetzten Anweisung oder der Funktion stößt.

Bei statischen Variablen erscheint diese Warnung, wenn der Compiler auf das Ende der Quelldatei stößt.


Condition is always true/false
Condition is always true ODER Condition is always false	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-ccc)

Immer wenn der Compiler auf einen Vergleich von Konstanten trifft, der (entsprechend der Natur der zu vergleichenden Werte) immer true oder false ergibt, wird diese Warnung ausgegeben, und die Bedingung zur Compilierungszeit ausgewertet.

Zum Beispiel:

  void proc(unsigned x){

    if (x >= 0)        /* ergibt immer 'true' */

    {

       ...

    }

  }


Array size for 'delete' ignored
Array size for 'delete' ignored	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-dsz)

Die C++ IDE gibt diese Warnung aus, wenn Sie beim Löschen eines Arrays die Größe des Arrays angegeben haben.

Die neue C++ Spezifikation macht dies überflüssig. Der Compiler übergeht dieses Programmkonstrukt.

Diese Warnung ermöglicht die Compilierung älterer Programme.


Base class 'class1' is also a base class of 'class2'
Base class 'class1' is also a base class of 'class2'	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-ibc)

Eine Klasse erbt von derselben Basisklasse sowohl direkt als auch indirekt. Solche nicht portablen Konstrukte sollten im Quelltext Ihres Programms nicht vorkommen.


Bit fields must be signed or unsigned int (warning)
Bit fields must be signed or unsigned int	Compiler-Warnung

(Die Kommandozeilenoption zur Anzeige dieser Warnung lautet -wbbf)

Bitfelder dürfen in ANSI C nicht vom Typ signed char oder unsigned char sein.

Falls Sie nicht im strengen ANSI-Standard compilieren, läßt der Compiler diese Programmkonstrukte zu, kennzeichnet sie jedoch mit dieser Warnung.


Overloaded prefix 'operator operator' used as a postfix operator
Overloaded prefix operator 'operator' used as a postfix operator	Compiler-Warnung

(Die Kommandozeilenoption zur Anzeige dieser Warnung lautet -wpre)

Aufgrund der letzten C++ Spezifikationen ist es nunmehr möglich, sowohl die Präfix- als auch Postfix-Versionen der Operatoren ++ und -- zu überladen.

Wird der Präfix-Operator überladen und im Zusammenhang als Postfix verwendet, so verwendet der Compiler den Präfix-Operator und gibt diese Warnung aus.

Dies ermöglicht die Compilierung älterer Programme.


Use qualified name to access nested type 'type'
Use qualified name to access member type 'identifier'	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-nst)

In älteren Versionen der C++ Spezifikation waren innerhalb von Klassen deklarierte typedef- und Tag-Namen im globalen Gültigkeitsbereich direkt sichtbar.

Aufgrund der neuesten C++ Spezifikationen muß diesen Namen Klasse::Bezeichner vorangestellt werden, wenn sie außerhalb des Gültigkeitsbereichs ihrer Klasse verwendet werden sollen.

Der Compiler gibt diese Warnung aus, wenn ein Name eindeutig in einer einzigen Klasse definiert ist. Der Compiler läßt die Verwendung ohne Klasse:: zu. Dies ermöglicht die Compilierung älterer Programme.


Conversion to 'type' will fail for members of virtual base 'class'
Conversion to 'type' will fail for members of virtual base 'class'	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung dieser Warnung lautet -w-mpc)

Diese Warnung wird nur ausgegeben, wenn die Kommandozeilenoption -Vv benutzt wird.

Diese Warnung kann bei der Konvertierung eines Zeigers auf ein Element in einen anderen Zeigertyp auf ein Element erscheinen, wenn die Klasse des Elementzeigers virtuelle Basisklassen beinhaltet.

Tritt der Fall ein, daß der Elementzeiger im Zuge der Konvertierung auf ein Element aus Klasse zeigt,

so kann die Konvertierung nicht durchgeführt werden. Das Ergebnis der Konvertierung zur Laufzeit ist dann ein Elementzeiger mit Wert Null.


Stack overflow
Stack overflow	Laufzeit-Meldung

Dieser Fehler wird angezeigt, wenn Sie eine Funktion mit der Option Test auf Stack Überlauf compilieren, wobei jedoch auf dem Stack nicht ausreichender Speicherplatz zur Verfügung steht, um die lokalen Variablen der Funktion anzulegen.

Weitere Fehlerursachen können sein:

 	Eine nicht terminierende Rekursion.

 	Eine Assembler-Prozedur, die den Stack nicht richtig verwaltet.

 	Ein großes Array innerhalb einer Funktion.


Abnormal program termination
Abnormal program termination	Laufzeit-Meldung

Da dem Programm nicht genügend Speicher zur Ausführung zur Verfügung stand, wurde abort aufgerufen.

Diese Meldung kann durch Überschreiben des Speichers verursacht werden.


Divide error
Divide error	Laufzeit-Meldung

Sie haben versucht, eine Integerzahl durch Null zu dividieren, was nicht erlaubt ist.


Floating point error: Divide by 0
Floating point error: Divide by 0	Laufzeit-Meldung

ODER	Floating point error: Domain

ODER	Floating point error: Overflow

Diese Fehler mit sofortigem Abbruch resultieren aus einer Fließkommaberechnung mit einem Ergebniswert im Unendlichen.

 	Division durch 0 bedeutet, das Ergebnis ist +INF (infinity, d.h. unendlich) oder -INF, ebenso wie bei 1.0/0.0.

 	Definitionsbereich bedeutet, das Ergebnis ist NAN (not a number, d.h. keine Zahl)

 	Überlauf (Overflow) bedeutet, das Ergebnis ist +INF oder -INF mit einem vollständigen Verlust der Genauigkeit, wie z.B. bei einer Zuweisung von 1e200*1e200 an einen Wert vom Typ double.


Floating point error: Partial loss of precision/Underflow
Floating point error: Partial loss of precision	Laufzeit-Meldung

ODER	Floating point error: Underflow

Diese Ausnahmen sind standardmäßig maskiert, da der Unterlauf zu Null konvertiert, und der Verlust der Genauigkeit ignoriert wird.


Floating point error: Stack fault
Floating point error: Stack fault	Laufzeit-Meldung

Auf dem Fließkomma-Stack ist ein Überlauf aufgetreten. Dieser Fehler kann durch Assembler-Anweisungen verursacht werden, die zu viele Register verwenden. Eine andere mögliche Ursache ist die fehlerhafte Deklaration einer Fließkommafunktion.

Das Programm gibt diese Fehlermeldung aus und ruft dann abort und _exit. auf.

Diese Fließkommafehler können durch Maskieren der Ausnahmebedingung unterdrückt oder mit Hilfe der Funktion signal abgefangen werden.


Type 'typename' may not be defined here
Type 'typename' may not be defined here	Compiler-Meldung

Klassen- und Aufzählungstypen dürfen nicht in einem Rückgabetyp einer Funktion, als Argumententyp einer Funktion, als Umwandlungsoperator oder als Cast-Typ spezifiziert sein.

Definieren Sie den gegebenen Typen, bevor Sie ihn in diesem Kontext verwenden.

Hinweis:	Häufig löst ein fehlendes Semikolon (;) nach einer Klassendeklaration diese Fehlermeldung aus. Vergewissern Sie sich, daß .alle Klassendeklarationen vor der fehlerauslösenden Zeile mit einem Semikolon abgeschlossen sind.


Cannot call 'main' from within the program
Cannot call 'main' from within the program	Compiler-Meldung

In C++ sind rekursive Aufrufe von main( ) nicht möglich


Application is running
Application is running	Laufzeit-Meldung

Sie haben versucht eine Anwendung zu starten, die bereits ausgeführt wird.

Wenn es sich um ein Windows-Programm handelt, überprüfen Sie ob die Nachrichtenschleife ordentlich beendet wurde.

PostQuitMessage(0);


Maximum precision used for member pointer type type
Maximum precision used for member pointer type 'type'	Compiler-Warnung

(Die Kommandozeilenoption zur Unterdrückung lautet -w-mpd)

Wenn Sie einen Zeigertypen auf ein Klassenelement verwenden, die Klasse noch nicht vollständig definiert wurde, und die Option -Vmd benutzt wird, muß der Compiler die allgemeine (und am wenigsten effiziente) Repräsentation für diesen Elementzeigertypen anwenden. Dieses erzeugt einen wenig effizienten Code (und der Typ des Elementzeigers wird unnötig groß) und kann Probleme hervorrufen, wenn Sie separat compilieren. Genauere Informationen finden Sie in der Compileroption -Vm.


Include files nested too deep
Include files nested too deep	Compiler-Meldung

Diese Meldung zeigt an, daß direkte oder indirekte, rekursive #include-Anweisungen verwendet wurden.


Cannot take address of 'main'
Cannot take address of 'main'	Compiler-Meldung

In C++ ist der Zugriff auf die Adresse der Hauptfunktion main nicht zulässig.


Ambiguous override of virtual base member 'base_function': 'derived_function'
Ambiguous override of virtual base member 'base_function': 'derived_function'	Compiler-Meldung

Eine virtuelle Funktion einer virtuellen Basisklasse wurde von zwei oder mehr verschiedenen Funktionen entlang verschiedener Wege der Vererbungshierarchie überschrieben. Zum Beispiel:

struct VB

{

virtual f();

};

struct A:virtual VB

{

virtual f();

};

struct B:virtual VB

virtual f();

}


Cannot throw 'type' -- ambiguous base class 'base'
Cannot throw 'type' -- ambiguous base class 'base'	Compiler-Meldung

Eine Klasse kann nicht mehr als eine Kopie einer (nicht virtuellen) Basisklasse enthalten.


Exception specification not allowed here
Exception specification not allowed here	Compiler-Meldung

Deklarationen von Zeigern auf Funktionen dürfen keine Ausnahmespezifizierungen enthalten.


Exception handling variable may not be used here
Exception handling variable may not be used here	Compiler-Meldung

Es wurde versucht, einen Wert der Ausnahmebehandlung zu benutzen, der ausschließlich besonderen Konstrukten zur Ausnahmebehandlung vorbehalten ist, z.B. GetExceptionCode().


Functions cannot return arrays or functions
Functions cannot return arrays or functions	Compiler-Meldung

Sie haben eine Funktion definiert, die ein Feld oder eine Funktion zurückgibt. Überprüfen Sie, ob entweder ein Zeiger auf ein Feld oder eine Funktion (vielleicht fehlt *) zurückgegeben werden sollte oder ob die Funktionsdefinition einen falschen Datentypen enthält.


Duplicate handler for 'type1', already had 'type'
Duplicate handler for 'type1', already had 'type2'	Compiler-Meldung

Es ist nicht zulässig, zwei Behandlungsroutinen für denselben Typ anzugeben.


The '...' handler must be last
The name handler must be last	Compiler-Meldung

In einer Liste von catch-Behandlungsroutinen, muß die angegebene Routine, sofern vorhanden, die letzte sein, d.h., es dürfen keine weiteren folgen.


VIRDEF name conflict for 'function'
VIRDEF name conflict for 'function'	Compiler-Meldung

Der Compiler muß zu lange ergänzte Namen auf eine bestimmte Länge kürzen, da ihm durch den Linker eine Maximallänge vorgegeben ist. Dieses Abschneiden kann (in sehr seltenen Fällen) aus zwei unterschiedlichen, zu langen Namen zwei für den Linker gleiche Namen machen. Wenn diese beiden Namen zufällig VIRDEF-Namen sind, so gibt der Compiler diese Fehlermeldung aus. Verändern Sie in diesem Fall einfach den Namen von Funktion derart, daß dieser Konflikt vermieden wird.


Goto into an exception handler is not allowed
Goto into an exception handler is not allowed	Compiler-Meldung

Ein Sprung in einen try-Block oder eine Ausnahmebehandlungsroutine, die einem try-Block zugeordnet ist, ist nicht zulässig.


'catch' expected
'catch' expected	Compiler-Meldung

In einem C++ Programm muß auf einen try-Block mindestens ein catch-Block folgen.


Type 'type' is not a defined class with virtual functions
Type 'type' is not a defined class with virtual functions	Compiler-Meldung

Es wurde ein dynamic_cast mit einem Zeiger auf eine Klasse benutzt, die entweder undefiniert ist oder keine virtuellen Elementfunktionen besitzt.


> expected
> expected	Compiler-Meldung

Bei einer new-style-Umwandlung (z.B.: dynamic_cast) fehlt das abschließende Zeichen >.


'type' is not a polymorphic class type
'type' is not a polymorphic class type	Compiler-Meldung

Dieser Fehler entsteht bei deaktivierter Compileroption -RT in den folgenden Fällen:

Wenn ein dynamic_cast auf einen Zeiger auf eine Klasse angewendet wird.

Oder:

Wenn sie versuchen, einen Zeiger auf ein Objekt einer Klasse zu löschen, die

einen virtuellen Destruktor besitzt.


'__except' or '__finally' expected following '__try'
'__except' or '__finally' expected following '__try'	Compiler-Meldung

In C muß ein _try-Block von einem _except- oder _finally-Block gefolgt werden.


Reference member 'member' initialized with a non-reference parameter
Reference member 'member' initialized with a non-reference parameter	Compiler-Meldung

Es wurde versucht, ein Referenzelement an einen Konstruktorparameter zu binden. Da der Parameter bei Beendigung des Konstruktors aufhört zu existieren, ist kein korrekter Ablauf zu erwarten.


Non-ANSI keyword used: 'keyword'
Non-ANSI keyword used: 'keyword'	Compiler-Warnung

(Die Kommandzeilenoption zur Anzeige dieser Warnung lautet -wnak)

Ein nicht in ANSI enthaltenes Schlüsselwort (z.B.: __fastcall) wurde benutzt, und strikte ANSI-Konformität war durch die Option -A eingestellt.


Handler for 'type1' hidden by previous handler for 'type2'
Handler for 'type1' hidden by previous handler for 'type2'	Compiler-Warnung

(Die Kommandzeilenoption zur Unterdrückung dieser Warnung lautet -w-hch)

Diese Warnung erscheint, wenn eine Behandlungsroutine für einen Typen D der von einem Typen B abgeleitet ist, nach der Routine für B spezifiziert wird. Die Routine für D wird daher niemals benutzt..


Cannot create precompiled header: 'reason'
Cannot create precompiled header: 'reason'	Compiler-Warnung

(Die Kommandzeilenoption zur Unterdrückung dieser Warnung lautet -w-pch)

Die vorkompilierte Header-Datei konnte aus einem der folgenden Gründe nicht angelegt werden:

Grund	Erklärung

write failed	Schreiben fehlgeschlagen: Der Compiler konnte die vorkompilierte Header-Datei nicht abspeichern. Wahrscheinlich ist die Festplatte voll.

code in header	Quelltext in der Header-Datei: Eine der Header-Dateien enthält einen Funktionsrumpf, der nicht inline ist.

initialized data in header	Initialisierte Daten in der Header-Datei: Eine der Header-Dateien enthält die Definition einer globalen Variablen. (In C eine globale Variable, in C++ jegliche Variable, die nicht als extern deklariert wurde.)

header incomplete	Header-Datei unvollständig: Die vorkompilierte Header-Datei endete in der Mitte einer Deklaration, zum Beispiel innerhalb einer Klassendefinition (dies passiert häufig, wenn eine schließende Klammer } fehlt).


Use '> >' for nested templates Instead of '>>'
Use '> >' for nested templates Instead of '>>'	Compiler-Warnung

(Die Kommandzeilenoption zur Unterdrückung dieser Warnung lautet -w-ntd)

Ein Whitespace-Zeichen (Leerzeichen, Tabulator) wird benötigt, um das abschließende >-Zeichen in einer verschachtelten Schablone abzugrenzen. Aber da es ein extrem häufiger Fehler ist, diese Whitespace-Zeichen auszulassen, akzeptiert der Compiler auch >> und erzeugt diese Warnung.


Initializing enumeration with type
Initializing enumeration with type	Compiler-Meldung

Sie versuchen eine enum-Variable mit einem anderen Typen zu initialisieren. Zum Beispiel:

enum count { zero, one, two } x = 2;

Dadurch wird diese Warnung hervorrufen, da 2 vom Typen int und nicht vom Typen enum count stammt. Besser ist es, bei der Initialisierung von enum-Typen einen enum-Bezeichner anstelle eines Integer-Literals zu verwenden.

Dies ist ein Fehler, wird jedoch nur als Warnung behandelt, damit bestehende Programme weiterhin ausgeführt werden können.


Main must have a return type of int
Main must have a return type of int	Compiler-Meldung

Die Funktion main in einem C++ Programm muß einen Rückgabewert vom Typen int zurückliefern.


'ident' is obsolete
'ident' is obsolete	Compiler-Warnung

(Die Kommandzeilenoption zur Unterdrückung dieser Warnung lautet -w-obs)

Ausgabe einer Warnung jede eingebundene C-Funktion, die spezifiziert wurde. Das stellt eine Warnung über veraltete Funktionen dar.

Zum Beispiel:

#ifdef __cplusplus

extern "C" {

#endif

void my_func(void);

#ifdef __cplusplus

}

#endif

#pragma obsolete my_func

main()

{

my_func();   // Erzeugung der Warnung

}


Unexpected termination during compilation [Module Seg#:offset]
Unexpected termination during compilation [Module Seg#:offset]	Compiler-Meldung

ODER	Unexpected termination during linking [Module Seg#:offset]

Bei diesen beiden Fehlern handelt es sich um eine schwerwiegende Störung der Borland Tools. Setzen Sie sich mit Borland in Verbindung, um für Ihr spezifisches Problem Unterstützung zu erhalten. Beschreiben Sie das Problem so detailliert und isoliert wie möglich, damit Borland oder Sie selbst am schnellsten eine Umgehung des Problems finden können.

Im allgemeinen können Compilerfehler umgangen werden, indem der Quelltext, der gerade compiliert wird, umgestellt wird. So könnte das Ändern der Reihenfolge der Variablendeklarationen oder Funktionen innerhalb des Quellmoduls das Problem beheben. In vielen Fällen hilft ebenfalls das Ändern des Gültigkeitsbereiches und des Abspeicherns der Variablen.

Fehler, die beim Linken auftreten, können in vielen Fällen vermieden werden, wenn die Menge der Debug-Informationen, die der Linker zu verarbeiten hat, nicht allzu groß ist. Compilieren Sie anstelle eines gesamten Projektes immer nur ein oder zwei Module mit Debug-Informationen.

Auch das Ändern der Reihenfolge, in der der Linker die Objektmodule verarbeitet, kann das Problem umgehen. Die IDE sendet die Objekte in der Reihenfolge an den Linker, wie sie im Projektbaum aufgelistet sind. Versuchen Sie, durch eine Verschiebung des Quelltextes in der Liste nach oben oder nach unten das Problem zu beheben.


Compiler stack overflow
Compiler stack overflow	Compiler-Meldung

Der Stack des Compilers ist übergelaufen. Die Ursache für diesen Fehler können viele Dinge sein, wie zum Beispiel sehr tief verschachtelte Anweisungen in einem Funktionskörper (z. B. if/else) oder Ausdrücke mit einer großen Anzahl an Operanden. Tritt diese Meldung auf, müssen Sie den Quelltext vereinfachen. Der Ausbau des Systems mit zusätzlichem Speicher kann bei dieser Fehlermeldung das Problem nicht beseitigen.


286/287 instructions not enabled
286/287 instructions not enabled	Compiler-Meldung

Verwenden Sie die Kommandozeilenoption -2 des Compilers, um den 286/287 Opcode zu aktivieren. Zu beachten ist hierbei, daß der erzeugte Code nicht auf 8086- oder 8088-Maschinen lauffähig ist.


Incorrect option:
Incorrect option:	Compiler-Meldung

In der Konfigurationsdatei oder bei einer Option in der Kommandozeile ist ein Fehler aufgetreten. Entweder hat der Compiler den Parameter der Konfigurationsdatei als nicht zulässig interpretiert oder der Parameter in der Kommandozeile wurde als nicht zulässig interpretiert. Überprüfen Sie für den ersten Fall, ob vor dem Parameter ein Bindestrich (-) steht.

Dieser Fehler kann auch auftreten, wenn Sie in Ihrem Quelltext die Option #pragma zusammen mit einer ungültigen Option verwendet haben.


Unable to execute command 'command'
Unable to execute command 'command'	Compiler-Meldung

TLINK oder TASM können nicht aufgefunden werden. Möglicherweise kann dies auch auf einen Defekt der Festplatte zurückzuführen sein.


Cannot evaluate function call
Cannot evaluate function call	Compiler-Meldung

Diese Fehlermeldung wird ausgegebn, wenn versucht wird, ein Objekt explitzit zu konstruieren oder eine virtuelle Funktion aufzurufen.

Bei integrierter Debugger-Ausdrucksauswertung werden Aufrufe von bestimmten Funktionen (dazu gehören implizite Konvertierungsfunktionen, Konstruktoren, Destruktoren, überladene Operatoren sowie Inline-Funktionen) nicht unterstützt.


Not a valid expression format type
Not a valid expression format type	Compiler-Meldung

Einem Ausdruck im Fenster Debug oder im Fenster Überwachen folgt eine ungültige Formatierungsanweisung. Eine gültige Formatierungsanweisung ist ein optionaler Wiederholungswert, dem ein Formatierungszeichen folgt (c, d, f[n], h, x, m, p, r oder s).


Cannot access an inactive scope
Cannot access an inactive scope	Compiler-Meldung

Es wurde versucht eine Variable auszuwerten oder zu untersuchen, die lokal zu einer inaktiven Funktion ist (Dies ist eine Meldung der Ausdruckauswertung des integrierten Debuggers).


Unable to create turboc.$ln
Unable to create turboc.$ln	Compiler-Meldung

Der Compiler kann die temporäre Datei TURBOC.$LN nicht erzeugen, da entweder auf die Festplatte nicht zugegriffen werden kann oder auf dieser kein freier Speicherplatz mehr zur Verfügung steht.


Conversion of near pointer not allowed
Conversion of near pointer not allowed	Compiler-Meldung

Ist das Programm nicht aufgerufen, kann ein near-Zeiger in dem Feld zur Ausdrucksauswertung nicht in einen far-Zeiger konvertiert werden. Dies ist der Fall, da für eine Konvertierung der aktuelle Wert von DS aus dem Benutzerprogramm benötigt wird, welcher nicht vorliegt.


' new' and 'delete' not supported
'new' and 'delete' not supported	Compiler-Meldung

Der intergrierte Debugger unterstützt die Auswertung der Operatoren new und delete nicht.


Exception handling not enabled
Exception handling not enabled	Compiler-Meldung

Bei nicht aktivierter Exception-Behandlung wurde ein try-Block aufgefunden.


No file names given
No file names given 	Compiler-Meldung

In der Kommandozeile wurden keine Dateinamen angegeben. Sie müssen den Namen einer Quelldatei angeben.


Multiple base classes not supported for VCL classes
Multiple base classes not supported for VCL classes	Compiler-Meldung

VCL-Klassen dürfen nicht mehrere Basisklassen haben

Zum Beispiel:

struct	__declspec(delphiclass) base1  {};

struct	__declspec(delphiclass) base2  {};

struct	derived : base1, base2         {}; // Fehler


Overloaded function resolution not supported
Overloaded function resolution not supported	Compiler-Meldung

Ausdrucksauswertung des integrierten Debuggers, die Auflösung von überladenen Funktionen oder Operatoren wird nicht unterstützt, noch nicht einmal, um eine Adresse aufzunehmen.


Templates not supported
Templates not supported	Compiler-Meldung

Während des Einsatzes des Kommandozeilen-Hilfsprogrammes H2ASH ist ein Fehler aufgetreten. Weitere Informationen zu diesem Hilfsprogramm finden Sie in der Online-Hilfe-Datei TSM_UTIL.TXT.


No type information
No type information 	Compiler-Meldung

Der integrierte Debugger hat für diese Variable keine Typinformation. Möglicherweise wurde das Modul compiliert, ohne daß der Debug-Schalter eingeschaltet war, oder es wurde mit einem anderen Compiler oder Assembler compiliert.


Virtual base classes not supported
Virtual base classes not supported for VCL classes	Compiler-Meldung

VCL-Klassen dürfen nicht virtuelle abgeleitet werden, auch nciht von anderen VCL-Klassen.

Zum Beispiel:

struct __declspec(delphiclass) base  {};

struct derived : virtual base        {};    // Fehler


Overlays only supported in medium, large, and huge memory models
Overlays only supported in medium, large, and huge memory models 	Compiler-Meldung

Nur Programme, die die Speichermodelle medium, large und huge verwenden, können überlagert werden.


Repeat count needs an lvalue
Repeat count needs an lvalue	Compiler-Meldung

Bei dem Ausdruck vor dem Komma (,) im Fenster Überwachter Ausdruck oder im Auswertungsfenster muß es sich um einen veränderbaren Speicherbereich handeln. So sind Ausdrücke wie die folgenden nicht zulässig:

i++,10d

x = y, 10m


Can't inherit non-RTTI class from RTTI base
Can't inherit non-RTTI class from RTTI base	Compiler-Meldung

ODER	Can't inherit RTTI class from non-RTTI base

Werden virtuelle Funktionen verwendet, muß das RTTI-Attribut aller Basisklassen mit dem der abgeleiteten Klasse übereinstimmen.


Side effects are not allowed
Side effects are not allowed	Compiler-Meldung

Seiteneffekte, wie zum Beispiel die Zuweisungen, ++, oder -- können im Fenster Überwachter Ausdruck des Debuggers nicht verwendet werden. Ein häufiger Fehler ist das Verwenden von x=y (nicht erlaubt) anstelle von x==y, um die Gleichheit von x und y zu überprüfen.


'member' is not a valid template type member
'member' is not a valid template type member	Compiler-Meldung

Es wurde festgestellt, daß das Element eines Template mit einigen aktuellen Argumenten, die von den formalen Argumenten eines einschließenden Template abhängen, nicht Element des angegebenen Template zu einer bestimmten Instanz ist.


'%s' requires run-time initialization/finalization
'%s' requires runtime initialization/finalization 	Compiler-Meldung

Eine als __thread (nur bei Win32) deklarierte globale Variable oder ein statisches Datenelement einer Template-Klasse wurde mit einem nicht konstanten Anfangswert initialisiert.

Eine als __thread (nur bei Win32) deklarierte globale Variable oder ein statisches Datenelement einer Template-Klasse hat dieselbe Typklasse wie Konstruktor oder Destruktor.


Cannot use tiny or huge memory model with Windows
Cannot use tiny or huge memory model with Windows 	Compiler-Meldung

Diese Meldung erklärt sich von selbst. Verwenden Sie statt dessen die Speichermodelle small, medium, compact oder large.


Declaration ignored
Declaration ignored 	Compiler-Warnung

(Die Kommandzeilenoption zur Unterdrückung dieser Warnung lautet -w-dig)

Während des Einsatzes des Kommandozeilen-Hilfsprogrammes H2ASH ist ein Fehler aufgetreten. Weitere Informationen zu diesem Hilfsprogramm finden Sie in der Online-Hilfe-Datei TSM_UTIL.TXT.

Voreinstellung = anzeigen


Macro definition ignored
Macro definition ignored 	Compiler-Warnung

(Die Kommandzeilenoption zur Unterdrückung dieser Warnung lautet -w-nma)

Während des Einsatzes des Kommandozeilen-Hilfsprogrammes H2ASH ist ein Fehler aufgetreten. Weitere Informationen zu diesem Hilfsprogramm finden Sie in der Online-Hilfe-Datei TSM-UTIL.TXT.


Constructor initializer list ignored
Constructor initializer list ignored 	Compiler-Warnung

(Die Kommandzeilenoption zur Unterdrückung dieser Warnung lautet -w-ncl)

Während des Einsatzes des Kommandozeilen-Hilfsprogrammes H2ASH ist ein Fehler aufgetreten. Weitere Informationen zu diesem Hilfsprogramm finden Sie in der Online-Hilfe-Datei TSM_UTIL.TXT.


Function body ignored
Function body ignored 	Compiler-Warnung

(Die Kommandzeilenoption zur Unterdrückung dieser Warnung lautet -w-nfd)

Während des Einsatzes des Kommandozeilen-Hilfsprogrammes H2ASH ist ein Fehler aufgetreten. Weitere Informationen zu diesem Hilfsprogramm finden Sie in der Online-Hilfe-Datei TSM_UTIL.TXT.


Initializer for object 'x' ignored
Initializer for object 'x' ignored 	Compiler-Warnung

(Die Kommandzeilenoption zur Unterdrückung dieser Warnung lautet -w-nin)

Während des Einsatzes des Kommandozeilen-Hilfsprogrammes H2ASH ist ein Fehler aufgetreten. Weitere Informationen zu diesem Hilfsprogramm finden Sie in der Online-Hilfe-Datei TSM_UTIL.TXT.


Functions are not expanded inline
Functions with exception specifications are not expanded inline	Compiler-Meldung

Auch:	Functions taking class by value arguments are not expanded inline

Exception-Spezifikationen werden nicht als Inline expandiert: Überprüfen Sie Ihren Inline-Code auf

Zeilen, die Exception-Spezifikationen enthalten.

Funktionen, denen Klassenargumente durch einen Wert übergeben werden, werden nicht als Inline expandiert: Ist die Exception-Behandlung aktiviert, können Funktionen, denen Klassenargumente durch einen Wert übergeben werden, nicht als Inline expandiert werden.

Hinweis:	Funktionen, denen Klassenparameter mit Hilfe von Referenzen übergeben werden, unterliegen nicht dieser Restriktion.


undef directive ignored
#undef directive ignored 	Compiler-Warnung

(Die Kommandzeilenoption zur Unterdrückung dieser Warnung lautet -w-nmu)

Während des Einsatzes des Kommandozeilen-Hilfsprogrammes H2ASH ist ein Fehler aufgetreten. Weitere Informationen zu diesem Hilfsprogramm finden Sie in der Online-Hilfe-Datei TSM_UTIL.TXT.


Declaration of static function '(...)' ignored
Declaration of static function function ignored 	Compiler-Warnung

(Die Kommandzeilenoption zur Unterdrückung dieser Warnung lautet -w-nsf)

Während des Einsatzes des Kommandozeilen-Hilfsprogrammes H2ASH ist ein Fehler aufgetreten. Weitere Informationen zu diesem Hilfsprogramm finden Sie in der Online-Hilfe-Datei TSM_UTIL.TXT.


Temporary used for parameter
Temporary used for parameter '???'	Compiler-Meldung

In C++ muß einer Variable oder einem Parameter des Referenztyps eine Referenz zu einem Objekt desselben Typs zugewiesen sein. Stimmen die Typen nicht überein, wird der aktuelle Wert einer temporären Variable des korrekten Typs zugewiesen und die Adresse der temporären Variable wird der Referenzvariable oder dem Referenzparameter zugewiesen.

Die Warnung bedeutet, daß sich die Referenzvariable oder der Referenzparameter nicht auf das bezieht, was Sie erwarten, jedoch auf eine temporäre Variable, die ansonsten nicht verwendet wird.

Im folgenden Beispiel erfordert die Funktion f eine Referenz zum Typ int und c ist vom Typ char:

f(int &amp);

char c;

f(c);

Anstatt f mit der Adresse von c aufzurufen, generiert der Compiler einen Code, der äquivalent zum C++ Quelltext ist::

int X = c, f(X);


Temporary used for parameter 2 in call to ???
Temporary used for parameter 2 in call to '???'	Compiler-Meldung

In C++ muß einer Variable oder einem Parameter des Referenztyps eine Referenz zu einem Objekt desselben Typs zugewiesen sein. Stimmen die Typen nicht überein, wird der aktuelle Wert einer temporären Variable des korrekten Typs zugewiesen und die Adresse der temporären Variable wird der Referenzvariable oder dem Referenzparameter zugewiesen.

Die Warnung bedeutet, daß sich die Referenzvariable oder der Referenzparameter nicht auf das bezieht, was Sie erwarten, jedoch auf eine temporäre Variable, die ansonsten nicht verwendet wird.

Im folgenden Beispiel erfordert die Funktion f eine Referenz zum Typ int und c ist vom Typ char

f(int &amp);

char c;

f(c);

Anstatt f mit der Adresse von c aufzurufen, generiert der Compiler einen Code, der äquivalent zum C++ Quelltext ist:

int X = c, f(X);


Internal compiler error
Internal compiler error 	Compiler-Meldung

In der internen Logik des Compilers ist ein Fehler aufgetreten. Der Fehler sollte eigentlich in der Praxis nicht auftreten, wird aber generiert, wenn für einen bestimmten Fehler keine genauere Fehlermeldung zu Verfügung steht.


DPMI programs must use the large memory model
DPMI programs must use the large memory model 	Compiler-Meldung

DPMI-Programme können nur mit dem Speichermodell large verwendet werden. Die Speichermodelle tiny, small, medium, compact und huge sind nicht zugelassen.


Recursive template function: '' instantiated ''
Recursive template function: '" instantiated '' 	Compiler-Meldung

Der Compiler hat eine rekursive Template-Funktion vorgefunden. Zum Beispiel:

    template<class T> void f(T x)

    {

       f((T*)0);   // rekursive Template-Funktion!

    }

    void main()

    {

       f(0);

    }

Der Compiler gibt für jede Verschachtelung der rekursiven Instantiierung eine Meldung aus, so daß es normalerweise offensichtlich ist, wo die Rekursion aufgetreten ist. Um ein rekursives Template zu beseitigen, verändern Sie entweder die Abhängigkeiten, oder Sie erstellen eine spezielle Version, die die Rekursion ausschließt. Fügen Sie zum Beispiel die folgende Funktionsdefinition in das obige Programm ein, entfernen Sie damit die endlose Rekursion:

    void f(int **)

    {

    }


Class 'classname' is abstract because of 'member = 0'
Class 'classname' is abstract because of 'member = 0'	Compiler-Meldung

Diese Nachricht wird direkt nach der Fehlermeldung "Cannot create instance of abstract class 'classname'" ("Kann Instanz der abstrakten Klasse Klassenname nicht finden") ausgegeben und erleichtert das Auffinden der Klasse, die der Compiler als abstrakte Klasse ansieht.

Beachten Sie bitte das folgende Beispiel eines ungültigen Versuchs, eine abstrakte Klasse zu instantiieren:

struct VB

{

virtual	void  f() = 0;

virtual	void  g() = 0;

virtual	void  h() = 0;

};

struct D1 : virtual VB

{

void   f();

};

struct D2 : virtual VB

{

void   h();

};

struct DD : D1, D2

{

}

v;   // Fehler 'DD' ist eine abstrakte Klasse

Der obige Programmabschnitt führt zu folgenden zwei Fehlermeldungen:

Error TEST.CPP 21: Cannot create instance of abstract class 'DD'

Error TEST.CPP 21: Class 'DD' is abstract because of 'VB::g() = 0'


User-defined message
User-defined message	Compiler-Meldung

Die Fehlermeldung, zu der Sie Hilfe angefordert haben, ist eine benutzerdefinierte Warnung.

In C++Builder werden benutzerdefinierte Meldungen durch die Compilersyntax #pragma message angezeigt.

Hinweis:	Abgesehen von Nachrichten, die Sie durch die Compileranweisung #pragma message ausgeben lassen, können benutzerdefinierte Warnungen auch durch Bibliotheken von Drittanbietern angezeigt werden. Sollten Sie Hilfe über eine solche Warnung benötigen, wenden Sie sich bitte an den Händler, bei dem Sie die Header-Datei, die die Warnung verursacht hat, erworben haben.


Internal code generator error
Internal code generator error	Compiler-Meldung

Im Code-Generator ist ein interner Verarbeitungsfehler aufgetreten. Setzen Sie sich mit der technischen Unterstützung von Borland in Verbindung.


Conversions of class to itself or base class not allowed
Conversions of class to itself or base class not allowed	Compiler-Meldung

Sie haben versucht, einen Umwandlungsoperator für die gleiche Klasse oder Basisklasse zu definieren.


Cannot declare or define 'identifier' here
Cannot declare or define 'identifier' here	Compiler-Meldung

Sie haben versucht, eine Schablone an nicht zulässiger Stelle oder ein Element eines Namensbereiches außerhalb seines Namensbereiches zu deklarieren.


Invalid use of namespace 'identifier'
Invalid use of namespace 'identifier'	Compiler-Meldung

Der Bezeichner eines Namensbereiches wurde in unzulässiger Weise verwendet, zum Beispiel in einem Ausdruck.


Cannot define 'identifier' using a namespace alias
Cannot define 'identifier' using a namespace alias 	Compiler-Meldung

Sie können einen Alias für einen Namensbereich nicht zur Definition eines Namensbereichelementes außerhalb seines Namensbereiches verwenden.


Namespace name expected
Namespace name expected	Compiler-Meldung

Hier wurde der Name eines Namensbereich erwartet.


Namespace member 'identifier' declared outside its namespace
Namespace member 'identifier' declared outside its namespace	Compiler-Meldung

Die Elemente eines Namensbereiches müssen innerhalb ihres Namensbereiches deklariert werden. Eine explizite Qualifizierung ist nur zur Definition eines Namensbereichelementes (zum Beispiel um einen Rahmen für eine in einem Namensbereich deklarierte Funktion bereitzustellen) erlaubt. Die Deklaration selbst muß sich innerhalb des Namensbereiches befinden.


Invalid template member definition
Invalid template member definition	Compiler-Meldung

Nach der Deklaration eines Template-Elements wurde entweder ein Semikolon, eine Initialisierung oder ein Rahmen erwartet, aber ein anderes, ungültiges Symbol gefunden. Diese Meldung erscheint, wenn ein Template-Element außerhalb der Schablone deklariert wurde und die Syntax fehlerhaft war.


Cannot use local type 'identifier' as template argument
Cannot use local type 'identifier' as template argument	Compiler-Meldung

Ein lokaler Typ wurde als Argument für ein Template  verwendet. Das ist ist nicht erlaubt.


CodeGuarded programs must use the large memory model and be targeted for Windows
CodeGuarded programs must use the large memory model and be targeted for Windows	Compiler-Meldung

Diese Meldung wird nur vom 16-Bit-Compiler ausgegeben. Programme, bei denen CodeGuard aktiviert ist, müssen das Speichermodell large verwenden und für den Einsatz unter Windows konzipiert sein.


Local data exceeds segment size limit
Local data exceeds segment size limit	Compiler-Meldung

Die lokalen Variablen der aktuellen Funktion sind größer als 64K.


RTTI not available for expression evaluation
RTTI not available for expression evaluation	Compiler-Meldung

Ausdrücke, die RTTI benötigen, werden vom Ausdrucksberechner des integrierten Debuggers nicht unterstützt. Diese Fehlermeldung wird nur vom Ausdrucksberechner ausgegeben (wenn Sie einen Ausdruck inspizieren, überwachen oder berechnen wollen), nicht vom Compiler.


Specialization after first use of template
Specialization after first use of template	Compiler-Meldung

Eine neue ANSI-Regel für C++ verlangt, daß die Spezialisierung einer Funktionsschablone vor ihrer ersten Verwendung deklariert werden muß. Die Meldung wird nur ausgegeben, wenn die ANSI-konforme Option -A gesetzt ist.


Earlier declaration of 'identifier'
Earlier declaration of 'identifier'	Compiler-Meldung

Diese Fehlermeldung erscheint nur nach den Meldungen "Multiple declaration for 'identifier'" ("Bezeichner mehrfach deklariert") und "Type mismatch in redeclaration of 'identifier'" ("Neudeklaration von Bezeichner mit anderem Typ"). Sie gibt an, wo die ursprüngliche Definition des Bezeichners zu finden ist, so daß Sie diese nicht suchen müssen.


Templates and overloaded operators cannot have C linkage
Templates and overloaded operators cannot have C linkage 	Compiler-Meldung

Sie haben versucht, eine C Einbindungsangabe für eine Schablone oder einen überladenen Operator zu verwenden. Diese Fehlermeldung wird meistens dann ausgeben, wenn die Deklaration von der Einbindungsangabe extern C { umrahmt ist.


Structure packing size has changed
Structure packing size has changed	Compiler-Warnung

(Die Kommandzeilenoption zur Unterdrückung dieser Warnung lautet -w-pck)

Diese Warnung wird ausgegeben, wenn die Ausrichtung einer Struktur sich nach der Miteinbindung

einer Datei verändert hat.

Sie dient dazu, Sie auf die Fälle aufmerksam zu machen, in denen eine Include-Datei die Packstruktur ändert und durch einen Fehler die ursprüngliche Ausrichtung am Ende nicht wieder herstellt. Sollte dies jedoch beabsichtigt sein, können Sie am Ende einer Include-Datei die Anweisung #pragma nopackwarning einfügen und damit die Ausgabe der Warnung für diese Datei unterdrücken.

Mit der Anweisung #pragma warn -pck kann diese Warnung auch generell ausgeschaltet werden..


Continuation character \ found in // comment
Continuation character \ found in // comment	Compiler-Warnung

(Die Kommandzeilenoption zur Unterdrückung dieser Warnung lautet -w-com)

Diese Warnung wird ausgegeben, wenn das C++ Kommentarzeichen // mit dem Zeilenfortsetzungszeichen Backslash in die nächste Zeile verlängert wird.

Die Meldung soll Sie vor Fällen warnen, in denen Zeilen, die Quelltext enthalten unabsichtlich einem Kommentar zugeordnet werden, weil dieser Kommentar mit einem Backslash aufhört.

Prüfen Sie bei Erhalt dieser Warnung sorgfältig, ob die Zeile hinter dem //-Kommentar tatsächlich noch zu diesem Kommentar gehören soll. Wenn nicht, entfernen Sie entweder den Backslash, oder fügen Sie ein weiteres Zeichen hinter ihm ein. Wenn ja, wäre es vielleicht der bessere Kodier-Stil, die nächste Zeile ebenfalls mit einem //-Kommentar zu beginnen.

Mit der Anweisung #pragma warn -com kann diese Warnung generell unterdrückt werden.


Assembler stack overflow
Assembler stack overflow	Compiler-Meldung

Der Assembler hatte während des Compilierens keinen Speicher mehr zur Verfügung. Überprüfen Sie den von der Fehlermeldung markierten Code-Bereich, um sicherzustellen, daß der Speicher richtig verwendet wird.


Call to undefined function 'function'
Call to undefined function 'function'	Compiler-Meldung

In Ihrer Quelldatei ist die aktuelle Funktion so deklariert worden, daß in C++ die Rückgabe eines anderen Wertes als vom Typ void (oder int in C) erwartet wird. Der Compiler hat jedoch eine Rückgabe ohne Wert gefunden. In C müssen int-Funktionen nicht unbedingt einen Wert zurückgeben, weil in den frühen C Versionen der Typ void zur Kennzeichnung von Funktionen, die keinen Wert zurückgeben, nicht vorhanden war.


Null pointer assignment
Null pointer assignment	Laufzeit-Meldung

Wenn ein Programm endet, das das Speichermodell medium verwendet, wird geprüft, ob die ersten beiden Bytes im Datensegment des Programmes sich verändert haben. Bei korrekt funktionierenden Programmen kann eine solche Änderung nicht vorkommen. Sollten die Bytes sich verändert haben, wird diese Meldung ausgegeben, um Sie darauf hinzuweisen, daß ein Wert (höchstwahrscheinlich) unter einem nicht initialisierten Zeiger gespeichert wurde.

Selbst wenn das Programm sonst völlig richtig funktionieren sollte, ist dies ein ernster Fehler, um den Sie sich sofort kümmern sollten. Eine unterlassene Korrektur des nicht initialisierten Zeigers kann zu einem unvorhersehbaren Verhalten des Programmes führen (einschließlich der Blockierung des Rechners in den Speichermodellen large, compact und huge).

Mit Hilfe des integrierten Debuggers können Sie Nullzeiger aufspüren.


Pure virtual function called
Pure virtual function called	Laufzeit-Meldung

Dies ist ein Laufzeitfehler. Er tritt auf, wenn der Rahmen einer abstrakten Funktion nicht erzeugt worden ist und der Compiler aus irgendeinem Grunde versucht, eine solche Funktion aufzurufen.


Invalid 'identifier' in scope override
Invalid 'expression' in scope override	Compiler-Meldung

Der Parser gibt diese Meldung aus, wenn ein Fehler in der Gültigkeitsbereichsvorgabe eines Ausdrucks, den Sie gerade überwachen oder inspizieren, auftritt. Sie können eine Symboltabelle, Compilierungseinheit, den Namen einer Quelldatei usw. als Gültigkeitsbereich des Ausdrucks angeben. Daraufhin erscheint diese Meldung immer dann, wenn der Compiler auf die nicht Symboltabelle, die Compilierungseinheit oder was auch immer zugreifen kann.


String literal not allowed in this context
String literal not allowed in this context	Compiler-Meldung

Diese Fehlermeldung wird vom Parser ausgegeben, wenn ein String-Literal in einem anderen Kontext, als dem eines Funktionsaufrufes vorgefunden wird.


The function 'function' is not available
The function 'function' is not available	Compiler-Meldung

Sie haben versucht, eine Funktion aufzurufen, die dem Parser zwar bekannt ist, aber in dem gerade debuggten Programm nicht enthalten war. Ein Beispiel dafür könnte eine Inline-Funktion sein.


Missing 'identifier' in scope override
Missing 'identifier' in scope override	Compiler-Meldung

Die Syntax einer Gültigkeitsbereichsvorgabe ist unvollständig. Diese Meldung wird vom Parser ausgeben.


Cannot take address of member function 'function'
Cannot take address of member function 'function'	Compiler-Meldung

Ein Ausdruck nimmt die Adresse einer Elementfunktion einer Klasse auf, aber diese Elementfunktion wurde im debuggten Programm nicht gefunden. Diese Meldung wird vom Parser ausgegeben.


Invalid function call
Invalid function call	Compiler-Meldung

Ein angeforderter Funktionsaufruf ist fehlgeschlagen, weil die Funktion im Programm nicht verfügbar war, einen Parameter nicht berechnet werden kann oder ein anderer Grund vorliegt. Diese Meldung wird vom Parser ausgegeben.


Printf/Scanf Fließkomma-Formate not linked
Printf/Scanf floating-point formats not linked	Laufzeit-Meldung

Fließkommaformate enthalten Formatinformationen zum Bearbeiten von Fließkommazahlen in bestimmten Laufzeitbibliotheksfunktionen, wie z. B. scanf() und atof(). Normalerweise sollten Sie es vermeiden, die Fließkommaformate (die ca. 1K benötigen) zu linken, es sei denn, sie werden von Ihrer Anwendung benötigt. Sie müssen die Fließkommaformate jedoch explizit für Programme linken, die Felder in einer begrenzten und spezifischen Weise bearbeiten.

In der folgenden Liste finden Sie mögliche Ursachen (angefangen mit dem häufigsten), um festzustellen, wie dieser Fehler behoben werden kann:

URSACHE: Fließkomma wurde auf None gesetzt. Es sollte aber auf Fast oder Normal gesetzt sein.

LÖSUNG: Setzen Sie das Fließkomma Fast oder Normal.

URSACHE: Entweder über-optimiert der Compiler oder die Fließkommaformate müssen wirklich gelinkt werden. Sie brauchen die Fließkommaformate, wenn Ihr Programm Fließkommas in einer begrenzten und spezifischen Weise bearbeitet. Unter bestimmten Bedingungen ignoriert der Compiler Fließkommas bei der Verwendung von scanf(). Dies tritt z.B. auf, wenn versucht wird, Daten in einer Fließkommavariablen zu lesen, die Teil eines in einer Struktur enthaltenen Arrays ist.

LÖSUNG: Fügen Sie folgenden Code in ein Quellmodul ein:

extern _floatconvert;

#pragma extref _floatconvert

URSACHE: Sie haben vergessen, den Adreßoperator & im scanf-Varaiblenausdruck anzugeben. Zum Beispiel:

float foo;

scanf("%f", foo);

LÖSUNG: Ändern Sie den Code, so daß der &-Operator verwendet wird. Ändern Sie den obigen Code z.B. folgendermaßen:

float foo;

scanf("%f", &foo);


Illegal number suffix

An ein numerisches Literal wurde ein Suffix angehängt, das vom Compiler nicht erkannt wird.

Zum Beispiel:

int i = 1234i15;   // Fehler: kein i15 Suffix

int j = 1234i16;   // OK


Illegal number suffix
Circular property definition

Zeigt an, daß eine Eigenschaftsdefinition sich direkt oder indirekt auf sich selbst bezieht.

Zum Beispiel:

struct pbase

{

     int __property ip1 = {read = ip2, write = ip2};

     int __property ip2 = {read = ip1, write = ip1};

};

Der obige Beispielcode verursacht diese Fehlermeldung bei jedem Gebrauch von ip1 oder ip2


access specifier of property property must be a member function

Nur Elementfunktionen und Datenelemente sind in Zugriffsspezifikationen von Eigenschaften zulässig.

Zum Beispiel:

int GlobalGetter(void)

{

     return 0;

}

struct pbase

{

     int	MemberGetter(void) {return 1;}

     int __property ip1 = { read = GlobalGetter }; // Fehler

     int __property ip2 = { read = MemberGetter }; // OK

};


Parameter mismatch in access specifier specifier of property property

Die Parameter der Elementfunktion, mit der auf eine Eigenschaft zugegriffen wird, entsprechen nicht den erwarteten Parametern.

Zum Beispiel:

struct	pbase

{

       void	Setter1(void)	{}

       void	Setter2(int)	{}

     int __property ip1 = { write = Setter1 }; // Fehler

     int __property ip2 = { write = Setter2 }; // OK

};


KStorage specifier not allowed for array properties
Storage specifier not allowed for array properties

Array-Eigenschaften dürfen die Angabe ‘stored’ nicht enthalten.

Zum Beispiel:

struct pbase

{

    int __property ap[char *] =

                           { stored = false }; // Fehler

};


VCL style classes must be constructed using operator new

VCL-Klassen dürfen nicht statisch definiert werden. Sie müssen beim Heap erstellt werden.

Zum Beispiel:

void	foo(void)

{

     Tobject   o1;     // Fehler;

     Tobject  *o2 = new TObject();

}


VCL style classes must be caught by pointer

Ein VCL-Objekt kann ur mit einem Zeiger angesprochen werden.

Zum Beispiel:

void foo(TObject *p)

{

     try

     {

          throw(p);

     }

     catch    (TObject o)    // Fehler

     {

     }

     catch  (TObject *op)    // OK

     {

     }

}


VCL classes have to be derived from VCL classes

Eine VCl-Klasse darf nicht von einer Nicht-VCL-Klasse abgeleitet werden.

Zum Beispiel:

struct base	// Basis ist keine VCL-Klasse

{

int	basemem;

};

struct __declspec(delphiclass) derived : base // oder

{

int	derivedmem;

};


Specifier requires VCL style class type

Die Speicherbezeichner stored, default und nodefault sind nur innerhalb von Eigenschaftsdeklarationen von Typen der VCL-Klasse zulässig.

Zum Beispiel:

struct regclass

{

     int __property ip1 = { stored  = false }; // Fehler

     int __property ip2 = { default = 42    }; // Fehler

     int __property ip3 = { nodefault       }; // Fehler

};

struct __declspec(delphiclass) vclclass

{

     int __property ip1 = { stored  = false }; // OK

     int __property ip2 = { default = 42    }; // OK

     int __property ip3 = { nodefault       }; // OK

};


VCL style classes require exception handling to be enabled

Wenn Sie in Ihrem Programm VCl-Klassen verwenden, dürfen Sie die Exception-Handler (Compiler-Option  -x-) nicht ausschalten, wenn Sie Ihren Quellcode kompilieren.


classid requires definition of TClass as a pointer type
__classid requires definition of TClass as a pointer type

Für die Verwendung von __classid muß eine Definition von TClass aus vcl.h vorhanden sein.

Zum Beispiel:

// #include <vcl/vcl.h> fehlt

struct __declspec(delphiclass)bar

{

     virtual int barbara(void);

};

void *foo(void)

{

     return classid(bar);    // Fehler

}


published or __automated sections only supported for VCL classes
__published or __automated sections only supported for VCL classes

Der Compiler muß eine besondere Art von vtable für Klassen generieren, die __published und __automated Abschnitte enthalten. Daher werden diese Abschnitt nur für VCL-Klassen unterstützt.

Zum Beispiel:

struct	regclass

{

int 	mem;

__published:	// Fehler: keine VCL-Klasse

int __property ip = { read = mem, write = mem };

};

struct	__declspec(delphiclass) vclclass

{

int 	mem;

__published:	// OK

int __property ip = { read = mem, write = mem };

};


Static data members not allowed in __published or __automated sections

Nur nicht-statische Datenelement und Elementfunktionen sind in __published und __automated Abschnitten zulässig.

Zum Beispiel:

struct	__declspec(delphiclass) vclclass

{

__published:

static int	staticDataMember;	// Fehler

};


Illegal type type in __automated section

Nur bestimmte Typen sind in __automated Abschnitten zulässig.

Zum Beispiel:

struct	__declspec(delphiclass) vclclass

{

__automated:

int	__fastcall fooInt(int);	// OK

long	__fastcall fooLong(long);	// Fehler: long ist unzulässig

};


Data member definition not allowed in __automated section

Nur Deklarationen von Elementfunktionen sind in __automated Abschnitten zulässig.

Zum Beispiel:

struct	__declspec(delphiclass) vclclass

{

__automated:

int	__fastcall fooInt(int);	// OK

int	memInt;	// Fehler

};


Only __fastcall functions allowed in __automated section

Die Aufrufkonvention für Funktionen, die in einem __automated Abschnitt deklariert sind, muß __fastcall sein.

Zum Beispiel:

struct	__declspec(delphiclass) vclclass

{

__automated:

int	__fastcall fooInt(int);	// OK

int	__cdecl    barInt(int);	// Fehler

};


Constructors and destructors not allowed in __automated section
Constructors and destructors not allowed in __automated section	Compiler-Fehler

Nur Deklarationen von Elementfunktionen sind in __automated Abschnitten zulässig.

Zum Beispiel:

struct	__declspec(delphiclass) vclclass

{

__automated:

int	__fastcall fooInt(int);	// OK

vclclass()  {}	// Fehler

};


Redeclaration of property not allowed in __automated section
Redeclaration of property not allowed in __automated section	Compiler-Fehler

Wenn Sie eine Eigenschaft in einem __automated Abschnitt deklarieren, muß es eine neue Deklaration sein. Die Übernahme von Eigenschaften ist nicht zulässig.

Zum Beispiel:

struct	__declspec(delphiclass) vclbaseclass

{

int 	__fastcall Get(void);

void 	__fastcall Set(int);

int __property ip1 = { read = Get, write = Set };

};

struct	vclderivedclass : vclbaseclass

{

int 	__fastcall NewGetter(void);

__automated:

__property ip1;	// Fehler

int __property ip2 = { read = Get, write = Set }; // OK

};


Only read or write clause allowed in property declaration in __automated section
Only read or write clause allowed in property declaration in __automated section	Compiler-Fehler

Die Speicherbezeichner stored, default und nodefault sind in Eigenschaftsdeklarationen in __automated Abschnitten nicht zulässig.

Zum Beispiel:

struct	__declspec(delphiclass) vclclass

{

int 	__fastcall Get(void);

__automated:

int __property ip1 = { read = Get };	      // OK

int __property ip2 = { read = Get, default = 42 }; // Fehler

};


Dispid number already used by identifier
Dispid number already used by identifier	Compiler-Fehler

Dispid-Anweisungen müssen eindeutig sein. Der Compiler überprüft dies.

Zum Beispiel:

struct	__declspec(delphiclass) vclclass

{

__automated:

int 	__fastcall foo1(void) __dispid(42);	// OK

int 	__fastcall foo2(void) __dispid(42);	// Fehler

};


Dispid only allowed in __automated sections
Dispid only allowed in __automated sections	Compiler-Fehler

Die Definition von Dispid-Anweisungen ist nur in __automated Abschnitten zulässig.

Zum Beispiel:

struct	__declspec(delphiclass) vclclass

{

int 	__fastcall foo1(void) __dispid(42);	// Fehler

__automated:

int 	__fastcall foo2(void) __dispid(43);	// OK

};


Suspicious pointer arithmetic
Suspicious pointer arithmetic	Compiler-Fehler

Diese Meldung gibt an, daß ein unbeabsichtigter Seiteneffekt in der Zeigerarithmetik (oder der Array-Indexierung) in einem Ausdruck gefunden wurde.

Zum Beispiel:

#pragma warn +spa

int	array[10];

int	foo(__int64 index)

{

return	array[index];

}

Der Wert von Index beträgt 64 Bits (Breite), während die Adresse von Array nur 32 Bits breit ist.


No type OBJ file present.  Disabling external types option
No type OBJ file present.  Disabling external types option.	Compiler-Warnung

(Die Kommandzeilenoption zur Unterdrückung dieser Warnung lautet -w-nto)

Eine präkompilierte Header-Datei verweist auf eine Typobjektdatei, die Typobjektdatei kann aber nicht gefunden werden. Dies ist kein schwerwiegendes Problem, vergrößert aber Ihre Objektdatei unnötigerweise.


Comparing signed and unsigned values
Comparing signed and unsigned values	Compiler-Warnung

(Die Kommandzeilenoption zur Unterdrückung dieser Warnung lautet -w-csu)

Da die Reichweite der Typen signed und unsigned unterschiedlich ist, könnte der Vergleich von signed und unsigned Werten ein unerwartetes Ergebnis liefern.

Zum Beispiel:

#pragma warn +csu

bool	foo(unsigned u, int i)

{

return	u < i;

}


Negating unsigned value
Negating unsigned value	Compiler-Warnung

(Die Kommandzeilenoption zur Unterdrückung dieser Warnung lautet -w-ngu)

Grundsätzlich ist es sinnlos, einen unsigned Wert zu negativieren, weil das Ergebnis ebenfalls unsigned ist.

Zum Beispiel:

#pragma warn +ngu

unsigned	foo(unsigned u)

{

return	-u;

}


Throw expression violates exception specification
Throw expression violates exception specification	Compiler-Warnung

(Die Kommandzeilenoption zur Unterdrückung dieser Warnung lautet -w-thr)

Die Funktion enthält einen throw-Ausdruck, dessen Typ nicht in der Exception-Spezifikation im Funktions-Header angegeben ist.

Zum Beispiel:

#pragma warn +thr

void	foo(int i) throw(double)

{

throw i;

}


Simple type name expected
Simple type name expected	Compiler-Fehler

Um die Zusammenarbeit zwischen Delphi und C++ Builder sicherzustellen, gibt es Einschränkungen zu den Typennamen in den Parameterlisten der Typen published closure. Die Parametertypen müssen einfache Typennamen mit optionalen const- und Zeigerangaben oder in der Referenzschreibweise sein.

Zum Beispiel:

struct __declspec(delphiclass) foo

{

     typedef void __fastcall (__closure *foo1)(SomeTemplateType<int> *);

     typedef SomeTemplateType<int> SimpleTypeName;

     typedef void __fastcall (__closure *foo2)(SimpleTypeName *);

published:

     __property foo1 prop1;  // Fehler

     __property foo2 prop2;  // OK

};


Function call terminated by unhandled exception 'value' at address 'addr'
Function call terminated by unhandled exception 'value' at address 'addr'	Compiler-Fehler

Diese Meldung wird ausgegeben, wenn ein Ausdruck, den Sie während des Debuggens auswerten, einen Funktionsaufruf enthält, der mit einer - ohne ein Handle versehenen - Ausnahme endet. Wenn Sie beispielsweise im Auswertungsdialogfeld des Debuggers eine Auswertung des Ausdrucks foo()+1 vornehmen wollen, und die Ausführung der Funktion foo() einen GP-Fehler verursacht, wird die obige Fehlermeldung ausgegeben.

Diese Meldung kann auch im Prüffenster erscheinen, weil dort ebenfalls Ergebnisse einer Auswertung angezeigt werden.


VCL style classes need virtual destructors
VCL style classes need virtual destructors	Compiler-Fehler

In VCL-Klassen definierte Destruktoren müssen virtuell sein.

Zum Beispiel:

struct	__declspec(delphiclass) vclclass1

{

~vclclass1() {}           // Fehler

};

struct	__declspec(delphiclass) vclclass2

{

virtual ~vclclass2() {}   // OK

};


= expected
= expected	Compiler-Fehler

Der Compiler hat ein Gleichheitszeichen an der Position, an der der Fehler gemeldet wurde, erwartet. Dies ist normalerweise ein Syntax- oder Schreibfehler.


Published property access functions must use __fastcall calling convention
Published property access functions must use __fastcall calling convention	Compiler-Fehler

Die Aufrufkonvention für Zugriffsfunktionen einer Eigenschaft (read, write und stored), die in einem __published Abschnitt deklariert werden, muß __fastcall sein. Dies gilt auch für geschützte Eigenschaften.

Zum Beispiel:

struct	__declspec(delphiclass) vclclass
{
int	__fastcall Getter1(void);
int	__cdecl    Getter2(void);
__published:
int __property ip1 = {read = Getter1};    // OK
int __property ip2 = {read = Getter2};    // Fehler
};


Bad character in parameters -> 'char'
Bad character in parameters -> 'char'	Linker-Meldung

(Unzulässiges Zeichen in der Kommandozeile oder in einer Parameterdatei: Zeichen)

Eines der folgenden Zeichen trat in der Kommandozeile oder in einer Parameterdatei auf:

  "    *    <    =    >    ?    [    ]    |

Es kann aber auch irgendein Steuerzeichen mit Ausnahme von horizontalem Tabulator, neuer Zeile, Wagenrücklauf oder [Strg][Z] aufgetreten sein.


Unable to open file 'filename'
Unable to open file 'filename' 	Linker-Meldung

(Die Datei Dateiname kann nicht geöffnet werden.)

Die genannte Datei kann nicht gefunden werden, weil sie entweder nicht existiert, ihr Name falsch geschrieben wurde oder sie sich in einem anderen Verzeichnis befindet.

Wenn Sie die Entwicklungsumgebung (IDE) verwenden, überprüfen Sie, ob die entsprechenden Verzeichnisse in dem Dialogfenster Optionen|Projekt|Verzeichnisse eingetragen sind.


Unresolved type external type referenced from module 'module'
Unresolved type external type referenced from module module	Linker-Meldung

(Modul Module verweist auf einen nicht aufgelösten externen Typ Typ.)

Diese Warnung bedeutet, daß der Compiler eine Debugger-Information in einer Kompiliereinheit ausgegeben hat, die auf einen externen Typen verweist. Die Definition des externen Typen konnte in keinem andern Modul oder OBJ-Typ gefunden werden. Dies kann vorkommen, wenn Pascal-Code mit aktiviertem Debugging kompiliert wird, der mit Pascal-Code gelinkt ist, der ohne Debugging kompiliert wird. Wenn Sie Pascal-Code in Ihr Projekt linken, sollten Sie, wenn Sie vorhaben den Pascal-Code zu debuggen, alles mit aktiviertem Debugging kompilieren. Wenn nicht kompilieren Sie alle ohne Debugging.


Debug information overflow in module ???
Debug information overflow in module module near file offset	Linker-Meldung

(Überlauf der Debug-Informationen im Modul Modul in der Nähe von Datei Offset.)

Diese Fehlermeldung erscheint, wenn Sie mit aktivierten Debug-Informationen kompilieren und mit Debug-Informationen linken und ein Modul mehr als 64 K an Zeilen enthält. Sie müssen im angegebenen Modul die Debug-Informationen ausschalten, oder das Modul in mehrere kleinere aufspalten. Der Offset ist der Datei-Offset in der OBJ, in der das Problem auftrat.


Unknown Optimization
Unknown Optimization 	Linker-Meldung

(Unbekannte Optimierung.)

Diese Fehlermeldung bezieht sich auf eine nicht dokumentierte Optimierungsfunktion.


Self relative fixupp overflowed in module 'module'
Self relative fixup overflowed in module 'module' 	Linker-Meldung

(Relatives Fixup auf sich selbst erzeugt einen Überlauf in Modul Modul)

Diese Meldung erscheint, wenn ein relativer Selbstverweis (ein Aufruf oder ein Sprung) von einem physikalischen Segment zum einem anderen gemacht wird. Dieses tritt bei der Verwendung von Assembler-Code häufig auf, aber auch bei Benutzung der Compiler-Option zu Segmentbenennung. Der Verweis von einem Code-Segment zum anderen ist sicher. Wenn jedoch der Verweis vom Code-Segment in ein Datensegment geht, so liegt wahrscheinlich ein Fehler im Assemblercode vor.

Sie können diese Warnung unterdrücken, indem Sie die Kommandozeilenoption /w-srf verwenden.


Using based linking for DLLs may cause the DLL to malfunction
Using based linking for DLLs may cause the DLL to malfunction 	Linker-Meldung

(Aufruf des Linkers mit dem Schalter /B kann bei DLLs zu Defekten führen.)

Diese Warnung tritt auf, wenn Sie den Schalter /B beim Linken einer DLL setzen. In fast allen Fällen entsteht ein Fehler und die Anwendung ist nicht lauffähig.

Sie können diese Warnung unterdrücken, indem Sie die Kommandozeilenoption /w-bdl verwenden.


Public symbol 'symbol' defined in both module <module1> and <module2>
Public symbol 'symbol' defined in both module 'module1' and 'module2' 	Linker-Meldung

(Öffentliches Symbol Symbol ist in Modul Modul1 und Modul Modul2 definiert.)

Ein Konflikt zwischen zwei öffentlichen Symbolen ist aufgetreten. Das bedeutet im Regelfall, daß es in zwei Modulen definiert ist.

Befinden sich beide Symbole in OBJ-Dateien, so erzeugt TLINK einen Fehler, da unklar ist, welches Symbol gültig ist.

TLINK gibt eine Warnung aus, wenn sich ein Symbol in einer OBJ-Datei, das andere Symbol sich hingegen in einer Bibliothek befindet. TLINK benutzt das Symbol aus der OBJ-Datei.


Import record does not match previous definition
Import record does not match previous definition 	Linker-Meldung

(Import-Record stimmt nicht mit vorhergehender Definition überein.)

Diese Warnung wird erzeugt, wenn ein IMPDEF-Datensatz in einer Importbibliothek erscheint und diese Importierung auch von einer DEF-Datei vorgenommen wird. Wenn die Beschreibungen der Importe sich im internen Namen oder in der Ordinalzahl unterscheiden, wird diese Meldung ausgegeben und die erste Definition wird benutzt.

Sie können diese Warnung unterdrücken, indem Sie die Kommandozeilenoption /w-imt verwenden.


Multiple stack segments found. The most recent one will be used.
Multiple stack segments found. The most recent one will be used. 	Linker-Meldung

(Mehrere Stacksegmente gefunden. Das letzte Segment wird benutzt.)

Sind zwei Stacksegmente mit unterschiedlichen Namen in den Object-Modulen definiert, wird diese Warnung ausgegeben. Der Startup-Code definiert ein Stacksegment für die Anwendung.

Sie können die Warnung mit der Kommandozeilenoption  /w-msk unterdrücken.


Empty LEDATA record in module 'module'
Empty LEDATA record in module 'module' 	Linker-Meldung

(Leerer Datensatz LEDATA im Modul Modul.)

Diese Warnung tritt auf, wenn der Übersetzer einen Daten-Record aussondert, der Daten enthält. Wenn dies passieren sollte, teilen Sie dieses dem Fachhändler Ihres Übersetzers mit. Es sollten keine negativen Seiteneffekte durch den Record entstehen.


Explicit stacks are ignored for PE images
Explicit stacks are ignored for PE images 	Linker-Meldung

(Explizite Stacks werden für PE-Programme ignoriert.)

Win32-Anwendungen sind Anwendungen im PE-Format, die keine expliziten Stacks besitzen. Das Stacksegment wird in das Programm eingebunden, aber es wird nicht als Stack für die Anwendung verwendet. Statt dessen wird der Parameter Stackgröße benutzt, um den Stack auf die entsprechende Größe zu setzen, und das Betriebssystem legt den Stack für die Anwendung an.


Export 'symbol' is duplicated
Export 'symbol' is duplicated 	Linker-Meldung

(Export Symbol ist doppelt.)

Diese Warnung erscheint, wenn zwei unterschiedliche Funktionen mit dem selben Namen über _export exportiert werden. TLINK benutzt in diesem Fall die erste Definition.


Old debug information in module 'module' will be ignored
Old debug information in module 'module' will be ignored 	Linker-Meldung

(Alte Debugger-Informationen im Modul Modul werden ignoriert.)

Debugger-Informationen in OBJ-Dateien, die zu TLINK nicht kompatibel sind, werden ignoriert.


Extern 'symbol' was not qualified with __import in module 'module'
Extern 'symbol' was not qualified with __import in module 'module' 	Linker-Meldung

(Extern Symbol ist nicht mit __import im Modul Modul gekennzeichnet.)

Win32-Anwendungen, die sich auf importierte Symbole beziehen, benötigen Indirektionen, um auf die Daten zuzugreifen. Bei Aufrufen, wird dieses automatisch von TLINK gehandhabt. Für Referenzen auf importierte Daten, muß der Compiler eine Indirektion erzeugen, oder die Anwendung läuft nicht korrekt. Der Compiler kann nur dann eine Indirektion erstellen, wenn das Symbol mit __import gekennzeichnet ist. Wenn TLINK eine segmentbezogene Referenz zu einem importierten Symbol findet, und dieses nicht mit __import versehen ist, so erscheint diese Meldung.

Sie können diese Warnung unterdrücken, indem Sie die Kommandozeilenoption /w-inq verwenden.


Debug information enabled, but no debug information found in OBJs
Debug information enabled, but no debug information found in OBJs 	Linker-Meldung

(Debugger-Informationen eingeschaltet, aber in den OBJ-Dateien wurden keine Debugger-Informationen gefunden.)

Sie wollen Debugger-Informationen einbinden, aber TLINK hat keine Debugger-Informationen in den OBJ-Dateien gefunden.


'filename' is not a valid library
'filename' is not a valid library 	Linker-Meldung

(Dateiname ist keine gültige Bibliothek.)

Dieser Fehler tritt auf, wenn der erste Datensatz in einer Bibliotheksdatei nicht der LIBSTART-Datensatz ist.

Dies ist der Fall, wenn der Linker etwas verarbeiten soll, was keine Bibliotheksdatei ist oder wenn die Bibliotheksdatei beschädigt ist.


Too many LNAMEs
Too many LNAMEs 	Linker-Meldung

(Zu viele LNAMEs.)

TLINK32 unterstützt bis zu 255 LNAMEs in einer OBJ-Datei.


Illegal ACBP byte in SEGDEF in module 'module'
Illegal ACBP byte in SEGDEF in module 'module' 	Linker-Meldung

(Ungültiges Byte ACBP in SEGDEF des Moduls Modul.)

Dieser Fehler tritt im allgemeinen aufgrund eines nicht kompatiblen Objektdateiformates auf. Wenn Sie Objektdateien linken, die mit einem anderen Compiler compiliert wurden, könnten diese Dateien nicht kompatibel zu TLINK32 sein. In diesem Fall müssen Sie alle betroffenen Module mit einem den C++Builder-Compilern neu compilieren.

Dieser Fehler kann auch auftreten, wenn der Rechner während des Compilierens neu gestartet wurde oder wenn der Compiler seine Objekt-Ausgabedatei nicht gelöscht hat, als die Tastenkombination [Strg][Untr] betätigt wurde. Compilieren Sie die Dateien in diesem Fall erneut.

Setzen Sie sich bei Fortbestehen des Fehlers mit der Technischen Unterstützung von Borland in Verbindung.


Illegal component to GRPDEF in module 'module'
Illegal component to GRPDEF in module 'module' 	Linker-Meldung

(Ungültige Komponente von GRPDEF im Modul Modul.)

Dieser Fehler tritt im allgemeinen aufgrund eines nicht kompatiblen Objektdateiformates auf. Wenn Sie Objektdateien linken, die mit einem anderen Compiler compiliert wurden, könnten diese Dateien nicht kompatibel zu TLINK32 sein. In diesem Fall müssen Sie alle betroffenen Module mit einem der C++Builder-Compiler neu compilieren.

Dieser Fehler kann auch auftreten, wenn der Rechner während des Compilierens neu gestartet wurde oder wenn der Compiler seine Objekt-Ausgabedatei nicht gelöscht hat, als die Tastenkombination [Strg][Untr] betätigt wurde. Compilieren Sie die Dateien in diesem Fall erneut.

Setzen Sie sich bei Fortbestehen des Fehlers mit der Technischen Unterstützung von Borland in Verbindung.


Unsupported option 'string'
Unsupported option 'string' 	Linker-Meldung

(Nicht unterstützte Option Zeichenkette.

Sie haben eine unbekannte Option in die Kommandozeile eingegeben.


Too many commas on command-line
Too many commas on command-line 	Linker-Meldung

(Zu viele Kommas in der Kommandozeile.)

Sie haben einen ungültigen Eintrag in der Kommandozeile angegeben. Überprüfen Sie den eingegebenen Befehl.


Malformed command-line
Malformed command-line 	Linker-Meldung

(Ungültige Kommandozeile.)

Sie haben in der Kommandozeile einen ungültigen Eintrag angegeben. Überprüfen Sie den eingegebenen Befehl.


Bad file name 'filename'
Bad file name 'filename' 	Linker-Meldung

(Ungültiger Dateiname Dateiname.)

TLINK wurde ein ungültiger Dateiname übergeben.


Failed read from 'filename'
Failed read from 'filename' 	Linker-Meldung

(Lesevorgang von Dateiname fehlgeschlagen.)

TLINK konnte aus der Datei nicht lesen.


Failed write to 'filename'
Failed write to 'filename' 	Linker-Meldung

(Schreibvorgang auf Dateiname fehlgeschlagen.)

TLINK konnte nicht in die Datei schreiben.


Terminated by user
Terminated by user 	Linker-Meldung

(Abbruch durch den Anwender.)

Sie haben die Tastenkombination [Strg][Untbr] betätigt.


Too many errors
Too many errors 	Linker-Meldung

(Zu viele Fehler.)

Die Anzahl der von TLINK gefundenen Fehler überschreitet die vom Benutzer festgelegte Obergrenze.


Bad object file 'filename' near file offset 'offset'
Bad object file 'filename' near file offset 'offset' 	Linker-Meldung

(Ungültige Objektdatei Dateiname nahe Datei-Offset Offset.)

TLINK hat eine ungültige OBJ-Datei gefunden. Dieses wird üblicherweise durch einen Übersetzerfehler ausgelöst.


No output file specified
No output file specified 	Linker-Meldung

(Keine Ausgabedatei angegeben.)

Sie haben keine Ausgabedatei angegeben.


Image base address must be a multiple of 0x10000
Image base address must be a multiple of 0x10000 	Linker-Meldung

(Programmstartadresse muß ein Vielfaches von 0x10000 sein.)

Programme müssen an einer 64kB-Grenze beginnen.


General error in module 'module'
General error in module 'module' 	Linker-Meldung

(Allgemeiner Fehler in Modul Modul)

TLINK32 gibt eine allgemeine Fehlermeldung aus und stürzt anschließend ab, wenn die vom Anwender angegebene MAP-Datei nicht geöffnet werden kann. Dies passiert gewöhnlich dann, wenn das in der Kommandozeile angegebene Verzeichnis (oder Laufwerk) nicht vorhanden ist. Dieser Linker versucht, die folgende Nachricht in die MAP-Datei auszugeben:

Fatal: cannot open mapfile...

Stellen Sie sicher, daß die Angaben über das Zielverzeichnis und das Ziellaufwerk der MAP-Datei richtig sind.


General error
General error 	Linker-Meldung

(Allgemeiner Fehler.)

Eine nicht abgefangene Ausnahme ist in TLINK aufgetreten. Informieren Sie die Technische Unterstützung von Borland über den Vorgang.


Mixed common types in module 'module'. Cannot mix COMDEFs and VIRDEFs
Mixed common types in module 'module'. Cannot mix COMDEFs and VIRDEFs. 	Linker-Meldung

(Unterschiedliche Standardtypen in Modul Modul. COMDEFs und VIRDEFs dürfen nicht gemischt werden.)

Sie dürfen COMDEFs und VIRDEFs nicht mischen. Stellen Sie den Schalter -FC aus, um die Generierung von COMDEFs zu vermeiden, oder den Schalter -Vs, um die Erstellung von VIRDEFs zu verhindern.


Out of memory for block 'block'
Out of memory for block 'block' 	Linker-Meldung

(Nicht genügend Arbeitspeicher für Block Block.)

TLINK hat nicht genügend Arbeitsspeicher zur Verfügung. Versuchen Sie den Speicher für Festplattencaches und/oder RAM-Laufwerken zu verkleinern.


Bad LF_POINTER in module 'module'
Bad LF_POINTER in module 'module' 	Linker-Meldung

(Ungültiger LF_POINTER in Modul Modul.)

Dieser Fehler wird typischerweise durch ungültige Debug-Informationen in der OBJ-Datei verursacht. Sie sollten die Technische Unterstützung von Borland verständigen.


Target index of FIXUPP is 0 in Module 'module'
Target index of FIXUP is 0 in Module 'module' 	Linker-Meldung

(Zielindex von FIXUP in Modul Modul ist 0.)

Dieses ist ein Übersetzerfehler.


Bad field list in debug information in module 'module'
Bad field list in debug information in module 'module' 	Linker-Meldung

(Ungültige Feldliste in der Debug-Information in Modul Modul)

Dieser Fehler wird typischerweise durch ungültige Debug-Informationen in der OBJ-Datei verursacht. Sie sollten die Technische Unterstützung von Borland verständigen.


Couldn't load DLL 'dll'
Couldn't load DLL 'dll' 	Linker-Meldung

(Konnte DLL dll nicht laden.)

TLINK konnte die angegebene DLL nicht laden. Stellen Sie sicher, daß sich die DLL in Ihrem Pfad befindet.


Couldn't get procedure address from DLL 'dll'
Couldn't get procedure address from DLL 'dll' 	Linker-Meldung

(Kann die Prozeduradresse aus der DLL dll nicht ermitteln.)

TLINK konnte eine Prozedur aus einer DLL nicht einbinden. Überprüfen Sie, ob Sie die korrekte Version der DLL nutzen.


Incorrect version of RLINK32.DLL
Incorrect version of RLINK32.DLL 	Linker-Meldung

(Falsche Version von RLINK.DLL)

Sie verwenden nicht die richtige Version von RLINK32.DLL. Überprüfen Sie, ob Sie die richtige Version der DLL installiert haben. Falls dies nicht der Fall sein sollte, löschen Sie die vorhandene Version und installieren Sie C++Builder neu.


Too many default libraries
Too many default libraries 	Linker-Meldung

(Zu viele Bibliotheken in der Voreinstellung.)

TLINK kann maximal 128 Standardbibliotheken verarbeiten.


16-bit segments not supported in module 'module'
16-bit segments not supported in module 'module' 	Linker-Meldung

(16-Bit-Segment in Modul Modul wird nicht unterstützt.)

16-Bit-Segmente werden für Win32-Anwendungen nicht unterstützt. Stellen Sie sicher, daß Sie die Anwendung nicht mit dem 16-Bit-Compiler übersetzt haben.


Multiple entry points defined
Multiple entry points defined 	Linker-Meldung

(Mehrere Einsprungspunkte definiert.)

Für die Anwendung wurden mehrere Einsprungspunkt definiert. Dieses kann auftreten, wenn Sie den Startup-Code zweimal angeben, oder wenn Sie Assembler Code benutzen, der eine Startadresse für die Anwendung definiert.


Duplicate ordinal for exports: 'string' ('ordval1') and 'string' (ordval2).
Duplicate ordinal for exports: 'string' ('ordval1') and 'string' ('ordval2') 	Linker-Meldung

(Doppelte Ordinalzahl für Exporte: Zeichenkette (ordval1) und Zeichenkette (ordval2))

Zwei Exportierungen teilen sich dieselbe Ordinalzahl. TLINK kann nicht entscheiden welcher Exportierung dieser Wert zugeordnet werden soll.


Attempt to export non-public symbol 'symbol'
Attempt to export non-public symbol 'symbol' 	Linker-Meldung

(Versuch, ein nichtöffentliches Symbol Symbol zu exportieren.)

Der EXPORTS-Abschnitt in der DEF-Datei spezifiziert ein Symbol, welches in keiner öffentlichen Definition genannt wird.


Fixup to zero length segment in module 'module'
Fixup to zero length segment in module 'module' 	Linker-Meldung

(Fixup auf ein Segment mit Länge Null in Modul Modul.)

Es wurde ein Verweis hinter das Ende eines Programmsegments angegeben. Dieses würde zum Zugriff auf eine ungültige Adresse führen. Daher wurde diese Referenz als fehlerhaft markiert.


No internal name for IMPORT in .DEF file
No internal name for IMPORT in DEF file 	Linker-Meldung

(Kein interner Name für IMPORT in DEF-Datei.)

Die DEF-Datei beinhaltet einen semantischen Fehler. Sie haben eine ungültige Importsequenz verwendet oder vergessen, den internen Name für einen Import vor den Modulnamen zu setzen. Zum Beispiel:

IMPORTS

     _foo.1

In diesem Fall ist _foo die zu importierende Funktion, aber die richtige Syntax lautet:

IMPORTS

     _foo=mydll.1


Converting reference to external type
Converting reference to external type type to void 	Linker-Meldung

(Verweis auf externen Typ Typ wird in void konvertiert.)

Diese Warnung bedeutet, daß der Linker einen Verweis innerhalb einer Debug-Information nicht in einen gültigen Typ auflösen konnte. Versuchen Sie, Ihre präkompilierten Header- und Typ-OBJ-Dateien (*.#*) zu löschen und kompilieren Sie Ihr Projekt erneut. In der Meldung ist Typ der Name des Typs, der nicht konvertiert werden konnte.


Debug info switch ignored for COM files
Debug info switch ignored for COM files 	Linker-Meldung

(Schalter für Debug-Information ignoriert für COM-Dateien.)

C++Builder erzeugt keine Debug-Informationen für COM-Dateien. Siehe die Beschreibung der Option /v.


Export 'symbol' has multiple ordinal values: 'value1' and 'value2'
Export 'symbol' has multiple ordinal values: 'value1' and 'value2' 	Linker-Meldung

(Export Symbol hat mehrere Ordinalwerte: Wert1 und Wert2.)

Der Linker hat ein Symbol mit mehreren Ordinalwerten gefunden. Da er nicht entscheiden kann, welcher Wert exportiert werden soll, verwendet er den Wert, den er zuerst findet.

Überprüfen Sie in der Moduldefinitionsdatei den Abschnitt EXPORTS und stellen Sie sicher, daß der Exportname nur einmal verwendet wird.


Bad secondary target for fixup in module 'module'
Bad secondary target for fixup in module 'module' 	Linker-Meldung

(Ungültiges Sekundärziel für Fixup in Modul Modul.)

Der Linker hat eine Objektdatei mit einem nicht kompatiblen Objektdateiformat gefunden.

Dieser Fehler tritt im allgemeinen aufgrund eines nicht kompatiblen Objektdateiformates auf. Wenn Sie Objektdateien linken, die mit einem anderen Compiler compiliert wurden, könnten diese Dateien nicht kompatibel zu TLINK32 sein. In diesem Fall müssen Sie alle betroffenen Module mit einem der C++Builder-Compiler neu compilieren.

Dieser Fehler kann auch auftreten, wenn der Rechner während des Compilierens neu gestartet wurde oder wenn der Compiler seine Ausgabedatei für Objekte nicht gelöscht hat, als die Tastenkombination [Strg][Untr] betätigt wurde. Compilieren Sie die Dateien in diesem Fall erneut.

Setzen Sie sich bei Fortbestehen des Fehlers mit der Technischen Unterstützung von Borland in Verbindung.


THREAD fixup found in module 'module'
THREAD fixup found in module 'module' 	Linker-Meldung

(THREAD Fixup in Modul Modul gefunden.)

Der Linker hat eine Objektdatei mit einem nicht kompatiblen Objektdateiformat gefunden.

Dieser Fehler tritt im allgemeinen aufgrund eines nicht kompatiblen Objektdateiformates auf. Wenn Sie Objektdateien linken, die mit einem anderen Compiler compiliert wurden, könnten diese Dateien nicht zu TLINK32 kompatibel sein. In diesem Fall müssen Sie alle betroffenen Module mit einem der C++Builder-Compiler neu compilieren.

Dieser Fehler kann auch auftreten, wenn der Rechner während des Compilierens neu gestartet wurde oder wenn der Compiler seine Objekt-Ausgabedatei nicht gelöscht hat, als die Tastenkombination [Strg][Untr] betätigt wurde. Compilieren Sie die Dateien in diesem Fall erneut.

Setzen Sie sich bei Fortbestehen des Fehlers mit der Technischen Unterstützung von Borland in Verbindung.


Far COMDEFs are not supported
Far COMDEFs are not supported 	Linker-Meldung

(COMDEF-Anweisungen mit far werden nicht unterstützt.)

Der Linker hat eine Objektdatei mit einem nicht kompatiblen Objektdateiformat gefunden.

Dieser Fehler tritt im allgemeinen aufgrund eines nicht kompatiblen Objektdateiformates auf. Wenn Sie Objektdateien linken, die mit einem anderen Compiler compiliert wurden, könnten diese Dateien nicht kompatibel zu TLINK32 sein. In diesem Fall müssen Sie alle betroffenen Module mit einem der C++Builder-Compiler neu compilieren.

Dieser Fehler kann auch auftreten, wenn der Rechner während des Compilierens neu gestartet wurde oder wenn der Compiler seine Objekt-Ausgabedatei nicht gelöscht hat, als die Tastenkombination [Strg][Untr] betätigt wurde. Compilieren Sie die Dateien in diesem Fall erneut.

Setzen Sie sich bei Fortbestehen des Fehlers mit der Technischen Unterstützung von Borland in Verbindung.


Illegal type of entry point
Illegal type of entry point 	Linker-Meldung

(Der Typ des Einsprungspunktes ist ungültig.)

Der Linker hat eine Objektdatei mit einem nicht kompatiblen Objektdateiformat gefunden.

Dieser Fehler tritt im allgemeinen aufgrund eines nicht kompatiblen Objektdateiformates auf. Wenn Sie Objektdateien linken, die mit einem anderen Compiler compiliert wurden, könnten diese Dateien nicht kompatibel zu TLINK32 sein. In diesem Fall müssen Sie alle betroffenen Module mit einem der C++Builder-Compiler neu compilieren.

Dieser Fehler kann auch auftreten, wenn der Rechner während des Compilierens neu gestartet wurde oder wenn der Compiler seine Objekt-Ausgabedatei nicht gelöscht hat, als die Tastenkombination [Strg][Untr] betätigt wurde. Compilieren Sie die Dateien in diesem Fall erneut.

Setzen Sie sich bei Fortbestehen des Fehlers mit der Technischen Unterstützung von Borland in Verbindung.


Unsupported COMENT OMF extension 'extension'
Unsupported COMENT OMF extension 'extension' 	Linker-Meldung

(Nicht unterstützte COMENT OMF-Erweiterung Erweiterung)

Der Linker hat eine Objektdatei mit einem nicht kompatiblen Objektdateiformat gefunden.

Dieser Fehler tritt im allgemeinen aufgrund eines nicht kompatiblen Objektdateiformates auf. Wenn Sie Objektdateien linken, die mit einem anderen Compiler compiliert wurden, könnten diese Dateien nicht kompatibel zu TLINK32 sein. In diesem Fall müssen Sie alle betroffenen Module mit einem der C++Builder-Compiler neu compilieren.

Dieser Fehler kann auch auftreten, wenn der Rechner während des Compilierens neu gestartet wurde oder wenn der Compiler seine Objekt-Ausgabedatei nicht gelöscht hat, als die Tastenkombination [Strg][Untr] betätigt wurde. Compilieren Sie die Dateien in diesem Fall erneut.

Setzen Sie sich bei Fortbestehen des Fehlers mit der Technischen Unterstützung von Borland in Verbindung.


Fixupps found for an LIDATA record
Fixupps found for an LIDATA record 	Linker-Meldung

(Fixupps für einen LIDATA-Satz gefunden)

Der Linker hat eine Objektdatei mit einem nicht kompatiblen Objektdateiformat gefunden.

Dieser Fehler tritt im allgemeinen aufgrund eines nicht kompatiblen Objektdateiformates auf. Wenn Sie Objektdateien linken, die mit einem anderen Compiler compiliert wurden, könnten diese Dateien nicht kompatibel zu TLINK32 sein. In diesem Fall müssen Sie alle betroffenen Module mit einem der C++Builder-Compiler neu compilieren.

Dieser Fehler kann auch auftreten, wenn der Rechner während des Compilierens neu gestartet wurde oder wenn der Compiler seine Objekt-Ausgabedatei nicht gelöscht hat, als die Tastenkombination [Strg][Untr] betätigt wurde. Compilieren Sie die Dateien in diesem Fall erneut.

Setzen Sie sich bei Fortbestehen des Fehlers mit der Technischen Unterstützung von Borland in Verbindung.


Bad loc for fixupp in module 'module' near file offset 'offset'
Bad loc for fixupp in module 'module' near file offset 'offset' 	Linker-Meldung

(Ungültige Speicherstelle für Fixup in Modul Modul nahe Datei-Offset Offset)

Der Linker hat eine Objektdatei mit einem nicht kompatiblen Objektdateiformat gefunden.

Dieser Fehler tritt im allgemeinen aufgrund eines nicht kompatiblen Objektdateiformates auf. Wenn Sie Objektdateien linken, die mit einem anderen Compiler compiliert wurden, könnten diese Dateien nicht kompatibel zu TLINK32 sein. In diesem Fall müssen Sie alle betroffenen Module mit einem der C++Builder-Compiler neu compilieren.

Dieser Fehler kann auch auftreten, wenn der Rechner während des Compilierens neu gestartet wurde oder wenn der Compiler seine Objekt-Ausgabedatei nicht gelöscht hat, als die Tastenkombination [Strg][Untr] betätigt wurde. Compilieren Sie die Dateien in diesem Fall erneut.

Setzen Sie sich bei Fortbestehen des Fehlers mit der Technischen Unterstützung von Borland in Verbindung.


Bad 'type' debug info in module 'module'
Bad 'type' debug info in module 'module' 	Linker-Meldung

(Ungültige Debug-Information für Typ in Modul Modul gefunden)

Der Linker hat eine Objektdatei mit einem nicht kompatiblen Objektdateiformat gefunden.

Dieser Fehler tritt im allgemeinen aufgrund eines nicht kompatiblen Objektdateiformates auf. Wenn Sie Objektdateien linken, die mit einem anderen Compiler compiliert wurden, könnten diese Dateien nicht kompatibel zu TLINK32 sein. In diesem Fall müssen Sie alle betroffenen Module mit einem der C++Builder-Compiler neu compilieren.

Dieser Fehler kann auch auftreten, wenn der Rechner während des Compilierens neu gestartet wurde oder wenn der Compiler seine Objekt-Ausgabedatei nicht gelöscht hat, als die Tastenkombination [Strg][Untr] betätigt wurde. Compilieren Sie die Dateien in diesem Fall erneut.

Setzen Sie sich bei Fortbestehen des Fehlers mit der Technischen Unterstützung von Borland in Verbindung.


Block overflow for block 'block'
Block overflow for block 'block' 	Linker-Meldung

(Blocküberlauf in Block Block)

Diese Meldung erscheint, wenn eine der internen Tabellen des Linkers überläuft.

Die internen Tabellen des Linkers enthalten Informationen wie etwa Linker- oder Debug-Daten. Die Tabellen wurden auf eine Standardgröße eingestellt, die für die Datenmenge Ihrer Anwendung nicht ausreichend war.

Bei Auftritt dieses Fehlers gibt der Linker eine TLINK32.INI genannte INI-Datei aus und fügt darin den übergelaufenen Block mit der Angabe seiner Größe ein. Editieren Sie die INI-Datei und erhöhen Sie Blockgröße.

Die DEF-Datei enthält ein ungültiges Format. Sie haben in die DEF-Datei eine ungültige Importsequenz eingegeben.


STACK/HEAP commit 'size' greater than reserve 'size'
STACK/HEAP commit 'size' greater than reserve 'size' 	Linker-Meldung

(STACK/HEAP Commit-Größe ist größer als die Reserve-Größe.)

Die Größe für Heap- oder Stack-Commit muß kleiner oder gleich der Größe für Heap- oder Stack-Reserve sein. Ändern Sie die Größen für Stack- und Heap-Reserve oder -Commit über die Werte für den 32-Bit-Linker im IDE oder über die Parameter HEAPSIZE und STACKSIZE in der Moduldefinitonsdatei.


Invalid stack reserve/commit size 'size'
Invalid stack reserve/commit size 'size' 	Linker-Meldung

(Ungültige Stack Reserve/Commit-Größe Größe)

Die angegebene Größe für Heap oder Stack Commit ist ungültig. Die Standard- und Mindestwerte für die Reserve- und Commit-Größen lauten wie folgt:

Reserve	Standard	Minimum

Stack	1Mb	4K

Heap	1Mb	0K

Commit	Standard	Minimum

Stack	8K	4K

Heap	4K	0K

Ändern Sie die Größen für Stack und Heap Reserve oder Commit, über die Werte für den 32-Bit-Linker im IDE oder über die Parameter HEAPSIZE und STACKSIZE in der Moduldefinitonsdatei.


Invalid file/object alignment value 'value'
Invalid file/object alignment value 'value' 	Linker-Meldung

(Ungültiger Wert Wert für Datei-/Objektausrichtung)

Sie haben in den Optionen für den 32-Bit-Linker einen ungültigen Wert für Datei- oder Objektausrichtung angegeben. Der Wert muß eine (dezimale oder hexadezimale) Zahl sein, die eine Potenz von 2 ist. Der kleinste zulässige Wert für die Dateiausrichtung ist 16. Der kleinste zulässige Wert für die Objektausrichtung ist 4096.


Image linked as EXE, but with DLL extension
Image linked as EXE, but with DLL extension 	Linker-Meldung

(Programm als EXE-Datei gelinkt, aber mit Dateinamenserweiterung DLL versehen)

Der Linker gibt diese Meldung aus, wenn eine ausführbare Datei erzeugt und dann in einer Datei mit der Namenserweiterung DLL gespeichert wurde.

Dies passiert gewöhnlich dann, wenn Sie eine DLL-Datei erzeugen wollten, aber vergessen haben, in der Kommandozeile eine DLL-Zieldatei mit der Linker-Option /T anzugeben (oder Sie haben die Linker-Option /T gar nicht angegeben). Wenn Sie eine DLL-Datei als Ziel erzeugen wollen, dann müssen Sie die dafür vorgesehene Option /T verwenden.


Possible unresolved external 'symbol' referenced from module 'module'
Possible unresolved external 'symbol' referenced from module 'module' 	Linker-Meldung

(Möglicherweise nicht aufgelöstes externes Symbol von Modul Modul referenziert)

Diese Warnung erscheint nur bei statischen Datenelementen von Klassen, die nur deklariert und nicht definiert wurden.


Images fixed at specific addresses typically will not run under Win32s
Images fixed at specific addresses typically will not run under Win32s 	Linker-Meldung

(Programme, die standardmäßig an einer speziellen Adresse fixiert werden, können unter Win32s nicht ausgeführt werden.)

Windows 32s lädt alle Anwendungen in einen einzigen Adreßraum. Es ist nicht möglich, im voraus zu sagen, an welche Speicherstelle Ihre Anwendung geladen wird, weil vor Ihrer Anwendung schon andere 32-Bit-Anwendungen geladen worden sein können.


Non-existent segment 'segment' in SEGMENTS section of .DEF file
Non-existent segment 'segment' in SEGMENTS section of .DEF file 	Linker-Meldung

(Nicht vorhandenes Segment Segment in SEGMENTS-Abschnitt der .DEF-Datei)

Sie haben im SEGMENTS-Abschnitt der DEF-Datei einen Segmentnamen angegeben, der in keiner der für diesen Link-Vorgang angegebenen Objekt- oder Bibliotheksdatei vorkommt.


.DEF file STACK/HEAP reserve size < 64K; 1MB default will be used
.DEF file stack/heap reserve size < 64K; 1MB default will be used 	Linker-Meldung

(Stack/Heap Reserve-Größe der DEF-Datei < 64K; der Standardwert von 1MB wird benutzt)

Die in der DEF-Datei angegebene Reserve-Größe für STACK oder HEAP ist kleiner als 64K. Der Linker gibt diese Warnung aus, um Sie darüber zu informieren, daß anstelle des angegebenen Wertes der Standardwert von 1MB verwendet wird.


Multiple public definitions for symbol 'symbol' in module 'module;' link case sensitively
Multiple public definitions for symbol 'symbol' in module 'module;' link case sensitively 	Linker-Meldung

(Mehrere öffentliche Definitionen für Symbol Symbol in Modul Modul; linken Sie unter Beachtung der Groß/Kleinschreibung)

Das angegebene Symbol wurde in dem selben Modul zweimal gefunden. Dies wird gewöhnlich durch die Verwendung von Symbolen verursacht, welche die Groß/Kleinschreibung beachten. Rufen Sie den Linker erneut unter Beachtung der Groß/Kleinschreibung auf.


Unresolved external 'symbol' referenced from module 'module'
Unresolved external 'symbol' referenced from module 'module' 	Linker-Meldung

(Nicht aufgelöstes externes Symbol von Modul Modul referenziert)

Das genannte Symbol wird im angegebenen Modul referenziert, aber in keiner der für diesen Link-Vorgang angegebenen Objektdateien oder Bibliotheksdateien definiert.

Prüfen Sie nach, ob das Symbol richtig geschrieben wurde.

Normalerweise wird dieser Fehler vom Linker für C und C++ Symbole ausgegeben, wenn einer der folgenden Fälle auftritt:

Sie haben die Deklarationen der Typen pascal und cdecl eines Symbols in verschiedenen Quelldateien nicht richtig aufeinander abgestimmt.

Sie haben den Namen einer OBJ-Datei, die Ihr Programm benötigt, nicht angegeben.

Sie haben die Emulationsbibliothek nicht gelinkt.

Beim Zusammenlinken von C++ Code mit C Modulen haben Sie vielleicht vergessen, die externen C-Deklarationen mit der Anweisung extern "C" (...) einzurahmen.

Es könnte zwischen den beiden Symbolen auch ein case-Konflikt aufgetreten sein.


T3 and T7 fixupps not allowed (module 'module')
T3 and T7 fixupps not allowed (module 'module') 	Linker-Meldung

(T3 und T7 fixupps sind nicht erlaubt (Modul Modul))

Der Linker hat eine Objektdatei mit einem nicht kompatiblen Objektdateiformat gefunden.

Dieser Fehler tritt im allgemeinen aufgrund eines nicht kompatiblen Objektdateiformates auf. Wenn Sie Objektdateien linken, die mit einem anderen Compiler compiliert wurden, könnten diese Dateien nicht kompatibel zu TLINK32 sein. In diesem Fall müssen Sie alle betroffenen Module mit einem der C++Builder-Compiler neu compilieren.

Dieser Fehler kann auch auftreten, wenn der Rechner während des Compilierens neu gestartet wurde oder wenn der Compiler seine Objekt-Ausgabedatei nicht gelöscht hat, als die Tastenkombination [Strg][Untr] betätigt wurde. Compilieren Sie die Dateien in diesem Fall erneut.

Setzen Sie sich bei Fortbestehen des Fehlers mit der Technischen Unterstützung von Borland in Verbindung.


Could not find precompiled type obj file ???
Could not find precompiled type object file filename. 	Linker-Meldung

(Präkompilierte Typenobjektdatei Dateiname konnte nicht gefunden werden.)

Der Linker konnte die OBJ-Datei nicht finden, die einige der Debug-Informationen enthält, die für das Linken erforderlich sind. Die kommt meistens vor, wenn Ihr Bibliothekspfad (Option -L) nicht auf das Verzeichnis verweist, in dem sich Ihre präkompilierten Header-Dateien befinden. Überprüfen Sie die Pfadangabe und versuchen Sie es erneut. Dies Warnung kann auch angezeigt werden, wenn die Typ-OBJ-Dateien gelöscht wurden, die präkompilierte Header-Datei aber nicht. Löschen Sie in diesem Fall die präkompilierte Header-Datei und kompilieren Sie die Anwendung erneut.


Unknown option 'option'
Unknown option 'option' 	Linker-Meldung

(Unbekannte Option Option)

Ein Slash-Zeichen (/), ein Bindestrich (-) oder ein DOS-Schalterzeichen wurde in der Kommandozeile oder in einer Response-Datei ohne eine darauf folgende zulässige Option gefunden. Es könnte sein, daß Sie zur Angabe einer Option die falsche Schreibweise verwendet haben.


Invalid target /T 'target'
Invalid target /T 'target' 	Linker-Meldung

(Ungültiges Ziel /T Ziel)

Der Kommandozeilenlinker hat ein ungültiges Ziel gefunden. Gültige Ziele sind: w und d.


Unknown Goodie
Unknown Goodie 	Linker-Meldung

(Unbekannte Wahl)

Eine nicht unterstützte Option wurde an den Kommandozeilenlinker übergeben.


Invalid size specified for segment packing
Invalid size specified for segment packing 	Linker-Meldung

(Ungültige Größe für Segmentpackgröße angegeben)

Eine nicht-dezimale Zahl wurde in die Kommandozeile für die Grenze der Segmentpackgröße eingegeben.


Invalid size specified for segment alignment
Invalid size specified for segment alignment 	Linker-Meldung

(Ungültige Größe für Segmentausrichtung angegeben)

Dieser Fehler tritt auf, wenn ein ungültiger Wert für die Einstellung der Segmentausrichtung angegeben wird. Die angegebene Wert muß ein ganzzahliges Vielfaches von 2 und kleiner als 64 kB sein. Gebräuchliche Werte sind 16 und 512. Dieser Fehler tritt nur beim Linken von Windows-Programmen auf.


Invalid map filename: 'filename'
Invalid map filename: 'filename' 	Linker-Meldung

(Ungültiger MAP-Dateiname Dateiname)

Der MAP-Dateiname hatte eine falsche Dateinamenserweiterung, wie etwa OBJ, EXE, DLL, LIB, DEF oder RES.


Invalid exe filename: 'filename'
Invalid exe filename: 'filename' 	Linker-Meldung

(Ungültiger EXE-Dateiname Dateiname)

Der EXE-Dateiname hatte eine falsche Dateinamenserweiterung, wie etwa OBJ, MAP, LIB, DEF oder RES.


Too many file names
Too many file names 	Linker-Meldung

(Zu viele Dateinamen)

Dieser Fehler tritt auf, wenn der Linker auf mehr als 64K an Zeichen in der Response-Datei stößt. Der Linker kann nur Response-Dateien bis zu einer Größe von 64K behandeln.

Sie müssen die Response-Datei oder Pfadnamen kürzen oder die OBJ-Dateien in einer Bibliothek unterbringen.


End of system input buffer encountered
End of system input buffer encountered 	Linker-Meldung

(Ende des Systemeingabepuffers erreicht)

Die von Ihnen eingegebene Zeile ist zu lang. Stellen Sie die Namen Ihrer Objektdateien und Bibliotheksdateien in einer Response-Datei ab, anstatt sie alle in die Kommandozeile einzugeben.


Invalid overlay switch specificaiton
Invalid overlay switch specification 	Linker-Meldung

(Ungültige Angabe eines Overlay-Schalters)

Sie haben eine Overlay-Option ohne einen oder mehrere Dateinamen dahinter angegeben. Löschen Sie den Schalter oder geben Sie die Namen der Dateien an, welche die Overlays enthalten.


No program entry point
No program entry point	Linker-Meldung

(Kein Programmeinsprungspunkt)

Diese Warnung erscheint, wenn in der Anwendung kein Anfangspunkt für die Ausführung definiert wurde. Die kommt meistens vor, wenn Sie vergessen, den Startcode zu linken.

Sie können diese Warnung mit der Kommandozeilenoption /w-ent unterdrücken.


No DEF file
No DEF file	Linker-Meldung

(Keine DEF-Datei)

Diese Warnung erscheint, wenn die Moduldefinitionsdatei im Projekt fehlt.


Out of memory in block address

Der Arbeitsspeicher des Linkers reicht nicht aus.

Lösungen

Reduzieren Sie die Größe aktiver RAM-Disks und/oder des Festplatten-Cache.

Schließen Sie eine oder mehrere Anwendungen, um Arbeitsspeicher freizusetzen.


Malloc of number bytes failed in module, line number

Der Arbeitsspeicher des Linkers reicht nicht aus.

Lösungen

Reduzieren Sie die Größe aktiver RAM-Disks und/oder des Festplatten-Cache.

Schließen Sie eine oder mehrere Anwendungen, um Arbeitsspeicher freizusetzen.


Realloc of number bytes failed in module, line number

Der Arbeitsspeicher des Linkers reicht nicht aus.

Lösungen

Reduzieren Sie die Größe aktiver RAM-Disks und/oder des Festplatten-Cache.

Schließen Sie eine oder mehrere Anwendungen, um Arbeitsspeicher freizusetzen.


Attempt to realloc NULL pointer in module, line number

Diese Meldung wird typischerweise durch eine falsche Debug-Information in der OBJ-Datei verursacht. Bitte notieren Sie sich die Umstände, unter denen diese Meldung verursacht wurde, und informieren Sie den technischen Support von Borland.


Attempt to free NULL pointer in module, line number

Intern wurde der Versuch unternommen, einen Speicherblock freizusetzen, der nicht zugeordnet war. Kompilieren Sie die gesamte Anwendung neu. Wird dieselbe Meldung erneut eingeblendet, sollten Sie sich die Umstände notieren, unter denen diese Meldung verursacht wurde, und den technischen Support von Borland informieren.


Out of memory

Der dynamisch zugewiesene Arbeitsspeicher des Linkers reicht für diesen Link-Vorgang nicht aus. Der gesamte Arbeitsspeicher ist verbraucht.

Diese Fehlermeldung erscheint immer dann, wenn die Grenzen des Gesamtarbeitsspeichers erreicht sind. In der Regel bedeutet dies, daß in den zu linkenden Objektdateien zu viele Module, externe Aufrufe, Gruppen oder Segmente definiert wurden.

Lösungen

Reduzieren Sie die Größe aktiver RAM-Disks und/oder des Festplatten-Cache.

Schließen Sie eine oder mehrere Anwendungen, um Arbeitsspeicher freizusetzen.


Assertion failed: module at "\address\", line number

Hier handelt es sich um einen internen Fehler. Bitte notieren Sie sich die Umstände, unter denen diese Meldung verursacht wurde, und informieren Sie den technischen Support von Borland.


Access violation.  Program terminated.

Bitte notieren Sie sich die Umstände, unter denen diese Meldung verursacht wurde, und informieren Sie den technischen Support von Borland.


Illegal type fixup index in module 'module'
Illegal type fixup index in module module

Die Objektdatei enthält einen unzulässigen Reparaturindex. Dieser Fehler entsteht, wenn der Compiler den falschen Index ausgibt oder wenn die Objektdatei beschädigt ist. Wenn diese Meldung weiterhin erscheint, sollten Sie sich mit dem technischen Support von Borland in Verbindung setzen.


User break. Link aborted.

Sie haben STRG+PAUSE gedrückt, während der Linker aktiviert war. Der Link-Vorgang wurde abgebrochen. (Es handelt sich hier nicht um eine Fehlermeldung, sondern um eine Bestätigung.)


Out of disk space

Die Festplatte bzw. das Laufwerk ist voll. Überprüfen Sie auch, ob Sie auf dem fraglichen Laufwerk über eine Schreibberechtigung verfügen.


Cannot write to disk

Ein Schreibvorgang auf die angegebene Platte konnte nicht erfolgreich ausgeführt werden. Überprüfen Sie, ob die Festplatte voll ist.


'text': ILINK32 does not support segmentation - use TLINK32
module: ILINK32 does not support segmentation - use TLINK32

Ein von ILINK32 verarbeitetes Modul enthielt vom Anwender definierte Code-Segmente oder Datensegmente verschiedener Klassen. Dies wird von ILINK32 nicht unterstützt. Sie müssen diese zusätzlichen Segmente entweder eliminieren oder TLINK32 verwenden.


Undefined symbol symbol referenced from module

Im angegebenen Modul wird auf ein benanntes Symbol verwiesen, das jedoch in keiner der an dem Link beteiligten Objektdateien und Bibliotheken definiert ist. Überprüfen Sie, ob das Symbol richtig geschrieben wurde.

In der Regel wird diese Meldung in einer der folgenden Situationen vom Linker für C- oder C++-Symbolen angezeigt:

Sie haben die Deklarationen eines Symbols des Typs __pascal und  __cdecl in verschiedenen Quelldateien nicht richtig aufeinander angepaßt.

Sie haben den vom Programm benötigten Namen einer .OBJ-Datei ausgelassen.

Sie haben die Emulationsbibliothek nicht gelinkt.

Wenn Sie C++-Code mit C-Modulen linken, haben Sie möglicherweise vergessen, externe C-Deklarationen mit extern „C“ zu versehen.

Es ist auch möglich, daß die Groß-/Kleinschreibung für zwei Symbole variiert.


Attempt to export non-public symbol 'symbol'
Attempt to export non-public symbol symbol

Im Abschnitt EXPORTS der Moduldefinitionsdatei wurde ein bestimmter Symbolname aufgelistet; allerdings wurde in den gelinkten Modulen kein als public deklariertes Symbol dieses Namens gefunden.

Bei einer Compilierung im C++Builder wird dieses Problem in der Regel durch die Namensverstümmelungen verursacht, die eine Folge des typensicheren Linkens des C++Builder sind. Bei allen Callback-Funktionen von Windows ist es erforderlich, in den Funktionsprototyp und in die Funktionsdefinition das Schlüsselwort _export einzufügen.

Sprachenunabhängige Gründe für diesen Fehler können eine falsche Schreibung (auch Groß-/Kleinschreibung), ein Exportfehler hinsichtlich der Groß-/Kleinschreibung oder ein Schreibfehler im Prozedurnamen sein.

Für Konvertierungen (Exporte), bei denen die Groß-/Kleinschreibung zu beachten ist, setzen die von Windows verwendeten Pascal-Aufrufkonventionen voraus, daß diese Symbole durchgängig in Großbuchstaben geschrieben werden.


Import by ordinal not supported by ILINK32

Sie haben versucht, im Abschnitt IMPORTS einer .DEF-Datei nach Ordinaltyp zu importieren. Dies wird von ILINK32 nicht unterstützt. ILINK32 unterstützt ausschließlich den Import nach Namen. Importieren Sie nach Namen oder verwenden Sie das Flag -o in TLINK32.


Public symbol 'symbol' defined in both module module1 and module2

Excel besteht ein Konflikt zwischen zwei als public deklarierten Symbolen. Dies bedeutet, daß ein Symbol in zwei Modulen definiert wurde.


Could not find object file filename

Der Compiler kann die in der Kommandozeile angegebene Datei nicht finden.


Error processing module module-name
Error processing module module

Der inkrementelle Linker kann das in der Fehlermeldung genannte Modul nicht verarbeiten.


Unable to open file 'filename'
Unable to open file filename

Die genannte Datei kann nicht gefunden werden; vermutlich existiert die Datei nicht, oder sie wurde falsch geschrieben, oder sie befindet sich in einem anderen Verzeichnis.

Wenn Sie mit der IDE arbeiten, sollten Sie sicher stellen, daß Sie im Dialogfeld Optionen | Verzeichnisse die richtigen Verzeichnispfade angegeben haben.


RLINK32 was not initialized

Die Datei RLINK32.DLL ließ sich nicht initialisieren. Die .DLL ist entweder beschädigt oder fehlt.


Could not load RLINK32.DLL

Der Linker konnte die angegebene DLL-Datei nicht finden. Überprüfen Sie, ob sich die DLL-Datei in einem Verzeichnis Ihres Pfads befindet.


Could not get procedure address from RLINK32.DLL

In der Datei RLINK32.DLL fehlt ein prozeduraler Export. Im BIN-Verzeichnis des C++Builder muß die falsche Version der Datei RLINK32.DLL gespeichert sein. Sie müssen diese Version der DLL löschen, und durch die korrekte Version der C++Builder-Quelle ersetzen. Sie können sie entweder von einem anderen System kopieren oder müssen den Borland C++Builder neu installieren.


Incompatible version of RLINK32.DLL

Im BIN-Verzeichnis des C++Builder muß die falsche Version der Datei RLINK32.DLL gespeichert sein. Sie müssen diese Version der DLL löschen, und durch die korrekte Version der C++Builder-Quelle ersetzen. Sie können sie entweder von einem anderen System kopieren oder müssen den Borland C++Builder neu installieren.


Unknown RLINK32 error

Fehler beim Verarbeiten von Ressourcen (allgemeiner Fehler). Kompilieren Sie die gesamte Anwendung neu. Wird dieselbe Meldung erneut eingeblendet, sollten Sie sich die Umstände notieren, unter denen diese Meldung verursacht wurde, und den technischen Support von Borland darüber informieren.


Undefined external type data-type

Dieser Fehler entsteht, wenn Sie Objektdateien mit Debug-Informationen mit Objektdateien ohne Debug-Informationen mischen. Die Fehlermeldung bedeutet, daß der Debugger keine Datentyp-Informationen anzeigen kann (Objekte des in der Meldung genannten Typs werden vom Debugger nicht aufgelöst). Die Lösung besteht darin, das Modul mit dieser Datentypdefinition noch einmal zu kompilieren; diesmal sollte die Debug-Information aktiviert sein.


Could not open filename (error code number)

Der inkrementelle Linker konnte die in der Meldung genannte Datei nicht öffnen.


Could not create filename (error code number)

Der inkrementelle Linker konnte die in der Meldung genannte Datei nicht erstellen.


Could not open filename (program still running?)

Die in der Meldung genannte Datei kann nicht öffnet werden. Wird das Programm noch ausgeführt?


Could not open filename (project already open in IDE?)

Die in der Meldung genannte Datei kann nicht öffnet werden. Wurde das Projekt in der IDE bereits geöffnet?


Failed to create map file filename (error code number)

Die in der Meldung genannte Map-Datei konnte nicht öffnet werden.


Symbol symbol marked as __import in module was public

Dieser Fehler tritt auf, wenn Sie ein Objektmodul durch Importe (etwa -D_RTLDLL) kompilieren, und ein anderes durch statische Bindung (kein solches Compilierungs-Flag). Das Ergebnis ist, daß ein Objekt im Modul globale Variablen erwartet, um einen indirekten Verweis im Assembly-Code zu verlangen (denn es handelt sich ja um einen Import), während das andere Objekt auf die Daten direkt verweisen will.

Die Lösung besteht darin, entweder alle Objektmodule entweder für die Verwendung von Importen oder für eine statische Bindung zu kompilieren.


Internal failure -- Retrying link...

In der internen Logik des Linkers ist ein Fehler aufgetreten.

Dieser Fehler sollte nicht vorkommen, wird aber aus Vollständigkeitsgründen angeführt für den Fall, daß ein besser spezifizierter Fehler nicht generiert wird.

Wenn dieser Fehler weiterhin besteht, notieren Sie sich sämtliche Fehlercodenummern, und setzen Sie sich mit dem technischen Support von Borland in Verbindung.


State invalid: 'module' at "\address\", line %d
State invalid: module at "\address\", line line

Fehler des internen Linkers. Wenn Sie diese Fehlermeldung erhalten, sollten Sie sich mit dem technischen Support von Borland in Verbindung setzen.


'module' contains invalid OMF record, type 0xHH
module contains invalid OMF record, type 0xHH

Die Objektdatei ist beschädigt. Erzeugen Sie sie neu, oder setzen Sie sich mit dem technischen Support von Borland in Verbindung.


General error in link set

Eine nichtbehandelte Ausnahme ist im Linker vorgekommen. Informieren Sie den technischen Support von Borland über die Umstände, die zu diesem Fehler geführt haben.


General linker message

ODER	General error in library file filename in module module near module file offset '0xyyyyyyyy'

ODER	General error in module module near module file offset '0xyyyyyyyy'

Der Linker stellt möglichst genaue Information dazu bereit, welcher Prozeß gerade ausgeführt wurde, als der unbekannte, fatale Fehler auftrat.

Wenden Sie sich an den technischen Support von Borland, und halten Sie Informationen über die .OBJ- oder .LIB-Dateien bereit.


Error parsing .DEF file

Bei der Syntaxanalyse (Parsing) der .DEF-Datei ist ein Fehler aufgetreten. Überprüfen Sie die Syntax der .DEF-Datei.


Unsupported 16-bit segment(s) in module 'module'
Unsupported 16-bit segment(s) in module module

16-Bit-Segmente lassen sich nicht in 32-Bit-Anwendungen linken. Die einzige Möglichkeit, 16-Bit-Segmente zu codieren, besteht darin, den Assembler (tasm32.exe) zu verwenden.


Bad OMF record type 'type' encountered in module 'module'
Bad OMF record type 'type' encountered in module 'module' 	Bibliotheksmeldung

(Unzulässiger OMF-Datensatztyp Typ in Modul Modulname)

Die Bibliotheksverwaltung hat einen unzulässigen Objektmodul-Formatdatensatz (OMF) beim Lesen des Objektmoduls entdeckt.

Da die Bibliotheksverwaltung die Header der Datensätze des Moduls bereits gelesen und verifiziert hat, ist das Objektmodul wahrscheinlich zerstört. Erzeugen Sie es erneut.


Could not allocate memory for per module data
Could not allocate memory for per module data 	Bibliotheksmeldung

(Nicht genügend Speicher für Modul-Daten)

Die Bibliotheksverwaltung hat nicht mehr genügend Speicher zur Verfügung.


Could not create list file 'filename'
Could not create list file 'filename' 	Bibliotheksmeldung

(Listendatei Dateiname konnte nicht erzeugt werden)

Die Bibliotheksverwaltung konnte für die Bibliothek keine Listendatei erzeugen. Dies kann an fehlendem Platten/Disketten-Speicher liegen.


Could not write output
Could not write output 	Bibliotheksmeldung

(Ausgabedatei konnte nicht geschrieben werden)

Die Bibliotheksverwaltung konnte die Ausgabedatei nicht beschreiben.


Error opening 'filename' (librarian)
Error opening 'filename' 	Bibliotheksmeldung

(Fehler beim Öffnen von Dateiname)

Die Bibliotheksverwaltung kann die angegebene Datei nicht öffnen.


Error opening 'filename' for output
Error opening 'filename' for output 	Bibliotheksmeldung

(Fehler beim Öffnen der Datei Dateiname für die Ausgabe)

Die Bibliotheksverwaltung konnte die angegebene Ausgabedatei nicht öffnen.


Error renaming 'filename' to 'filename'
Error renaming 'filename' to 'filename' 	Bibliotheksmeldung

(Fehler beim Umbenennen von Dateiname1 in Dateiname2)

Dieser Fehler tritt auf, wenn die Bibliotheksverwaltung eine temporäre Bibliotheksdatei erzeugt und die temporäre Datei den Namen der Zielbibliothek erhält.

Dieser Fehler deutet auf eine ausschließlich lesbare Zieldatei hin.


Library too large, restart with library page size 'size'
Library too large, restart with library page size 'size' 	Bibliotheksmeldung

(Bibliothek zu groß, erneuter Start mit Bibliothek-Seitengröße Größe)

Die Bibliothek konnte nicht mit der bestehenden Bibliotheks-Seitengröße erzeugt werden.


Not enough memory for command-line buffer
Not enough memory for command-line buffer 	Bibliotheksmeldung

(Nicht genügend Speicher für Kommandozeilen-Puffer)

Dieser Fehler erscheint, wenn TLIB nicht mehr genügend Speicher zur Verfügung hat.


Object module 'filename' is invalid
Object module 'filename' is invalid 	Bibliotheksmeldung

(Ungültiges Objektmodul Dateiname)

Die Bibliotheksverwaltung konnte den der Bibliothek hinzuzufügenden Header-Record des Objektmoduls nicht interpretieren.

TLIB geht davon aus, daß es sich um ein unzulässiges Modul handelt.


Out of memory (librarian)
Out of memory 	Bibliotheksmeldung

(Nicht genügend Speicher)

Aus irgendwelchen Gründen hatten die Bibliotheksverwaltung oder die C++ IDE nicht mehr genügend Speicher während der Erzeugung der Bibliothek zur Verfügung. Bei vielen besonderen Ursachen wird eine detailliertere Meldung ausgegeben.

Schließen Sie eine oder mehrere Anwendungen.


Out of memory creating extended dictionary
Out of memory creating extended dictionary 	Bibliotheksmeldung

(Nicht genügend Speicher für erweiterte Symboltabelle)

Die Bibliotheksverwaltung hat nicht mehr genügend Speicher zur Verfügung, um eine erweiterte Symboltabelle für eine Bibliothek zu erzeugen.

Die Bibliothek wird ohne erweitertes Verzeichnis erstellt.


Out of memory reading LE/LIDATA record from object module
Out of memory reading LE/LIDATA record from object module 	Bibliotheksmeldung

(Nicht genügend Speicher, Datensatz LE/LIDATA aus Objektmodul kann nicht gelesen werden)

Die Bibliotheksverwaltung versucht einen Datensatz aus dem Objektmodul einzulesen, verfügt jedoch nicht über den notwendigen Speicher.

Falls das hinzuzufügende Modul ein oder mehrere große Datensegmente besitzt, sollten Sie versuchen, das Modul vor allen anderen Modulen hinzuzufügen.


Out of space allocating per module debug struct
Out of space allocating per module debug struct 	Bibliotheksmeldung

(Speicher für Debugging-Struktur des Moduls kann nicht reserviert werden)

Die Bibliotheksverwaltung konnte den Speicher für die Debug-Informationen eines bestimmten Objektmoduls nicht belegen.

Das Problem kann gelöst werden, indem die Debug-Informationen einiger Module, die der Bibliothek hinzugefügt werden sollen, entfernt werden.


Output device is full
Output device is full 	Bibliotheksmeldung

(Kein Platz auf Ausgabegerät)

Es ist kein Platz mehr auf dem Ausgabegerät vorhanden. Dieser Fehler deutet normalerweise darauf hin, daß die Platte/Diskette voll ist.


'path' - path is too long
'path' - path is too long 	Bibliotheksmeldung

(Pfad Pfadname zu lang)

Dieser Fehler erscheint, wenn der Pfadname einer Bibliotheks- oder Moduldatei länger als 64 Zeichen ist.


Public 'symbol' in module 'module1' clashes with prior module 'module2'
Public 'symbol' in module 'module1' clashes with prior module 'module2' 	Bibliotheksmeldung

(Öffentliches Symbol im Modul Modul1 kollidiert mit vorhergehendem Modul2)

Ein öffentliches Symbol darf nur einmal in einer Bibliotheksdatei erscheinen. Ein Modul kann nicht in eine Bibliothek eingefügt werden, da ein in diesem Modul enthaltenes öffentliches Symbol bereits in einem anderen Modul der Bibliothek vorkommt.

Die Meldung in der Befehlszeile gibt den Namen von Modul2 wieder.


Record kind 'num' found, expected theadr or lheadr in module 'filename'
Record kind 'num' found, expected theadr or lheadr in module 'filename' 	Bibliotheksmeldung

(Record-Typ Nummer gefunden, im Modul Dateiname wurde jedoch theadr oder lheadr erwartet)

Die Bibliotheksverwaltung konnte den in die Bibliothek einzufügenden Header-Datensatz des Objektmoduls nicht interpretieren und nimmt an, daß es sich um ein ungültiges Modul handelt.


Record length 'len' exceeds available buffer in module 'module'
Record length 'len' exceeds available buffer in module 'module' 	Bibliotheksmeldung

(Record-Länge Länge größer als verfügbarer Puffer im Modul Modulname)

Dieser Fehler tritt auf, wenn die Länge eines Records größer ist als der zum Laden verfügbare Puffer im Modul.

Dieser Fehler erscheint, wenn Bibliotheksverwaltung nicht mehr genügend dynamischen Speicher zu Verfügung hat.


The combinations '+*' or '*+' are not allowed
The combinations '+*' or '*+' are not allowed 	Bibliotheksmeldung

(Die Kombinationen +* oder *+ sind nicht erlaubt)

Gleichzeitiges Hinzufügen und Extrahieren eines Objektmoduls aus einer Bibliothek ist nicht zulässig.


User break, library aborted
User break, library aborted 	Bibliotheksmeldung

(Unterbrechung durch den Anwender, Bibliothek nicht erzeugt)

Sie haben während des Compilierens in der IDE den Schalter Abbrechen aktiviert. Die Bibliothek wurde nicht erzeugt.

(Dies ist kein Fehler, sondern lediglich eine Bestätigung.)


Added file 'filename' does not begin correctly, ignored
Added file 'filename' does not begin correctly, ignored 	Bibliotheksmeldung

(Hinzugefügte Datei Dateiname beginnt falsch und wurde ignoriert)

TLIB hat entschieden, daß es sich bei der hinzuzufügenden Datei nicht um ein Objektmodul handelt. Es wird nicht versucht, die Datei der Bibliothek hinzuzufügen.

Die Bibliothek wird dennoch erzeugt.


Cannot write GRPDEF list, extended dictionary aborted
Cannot write GRPDEF list, extended dictionary aborted 	Bibliotheksmeldung

(Liste GRPDEF kann nicht geschrieben werden, erweitertes Verzeichnis wird nicht angelegt)

Die Bibliotheksverwaltung kann die erweiterte Symboltabelle nicht an das hintere Ende der Bibliotheksdatei schreiben. Es ist möglicherweise nicht mehr genügend Platz auf der Platte/Diskette.


'filename' couldn't be created, original won't be changed
'filename' couldn't be created, original won't be changed 	Bibliotheksmeldung

(Dateiname konnte nicht erzeugt werden, Original wird nicht verändert)

Sie haben versucht, ein Objekt zu extrahieren; die Bibliotheksverwaltung kann jedoch die Object-Datei, in die das Modul extrahiert werden soll, nicht erzeugen.

Entweder existiert die Datei bereits, doch nur mit Lesezugriff, oder es ist nicht mehr genügend Platz auf der Platte/Diskette.


'reason' - extended dictionary not created
'reason' - extended dictionary not created 	Bibliotheksmeldung

ODER	Library contains COMDEF records - extended dictionary not created

(Grund - erweiterte Symboltabelle nicht erzeugt ODER Bibliothek enthält Datensätze vom Typ COMDEF - erweitertes Verzeichnis nicht erzeugt)

Wenn die Meldung "Library contains COMDEF records" angezeigt wird, enthält ein Objektdatensatz, der der Bibliothek hinzugefügt werden soll, einen Datensatz COMDEF. Dies verträgt sich nicht mit der Option für ein erweitertes Verzeichnis.


'filename' file not found
'filename' file not found 	Bibliotheksmeldung

(Datei Dateiname nicht gefunden)

Die IDE erzeugt die Bibliothek, indem die bestehende Bibliothek entfernt und neu erstellt wird. Falls eines der angegebenen Objekte nicht existiert, ist die Bibliothek unvollständig und dieser Fehler wird generiert.

Wenn die IDE das Fehlen eines Objekts anzeigt, wurde entweder das Quelltext-Modul nicht compiliert oder es sind Fehler bei der Compilierung aufgetreten.


Invalid page size value ignored
Invalid page size value ignored 	Bibliotheksmeldung

(Unzulässiger Wert für Seitengröße wurde ignoriert)

Die Bibliotheksverwaltung hat eine unzulässige Seitengröße entdeckt.

Die Seitengröße muß eine ganze Zahl sein, die eine Potenz von 2 ist.


Memory full listing truncated!
Memory full listing truncated! 	Bibliotheksmeldung

(Speicher voll, Listendatei unvollständig)

Die Bibliotheksverwaltung hatte bei der Erstellung einer Bibliotheks-Listendatei nicht mehr genügend Speicher zur Verfügung. Es wird zwar eine Listendatei erzeugt, diese ist jedoch unvollständig.


Results are safe in file 'filename'
Results are safe in file 'filename' 	Bibliotheksmeldung

(Ergebnisse in Datei Dateiname gesichert)

Die Bibliotheksverwaltung hat die Bibliothek erfolgreich als temporäre Datei angelegt, kann jedoch die Datei nicht in den gewünschten Bibliotheksnamen umbenennen.

Die temporäre Datei wird nicht gelöscht (wodurch die Bibliothek beibehalten werden kann).


Unknown command line switch 'X' ignored
Unknown command line switch 'X' ignored 	Bibliotheksmeldung

(Unbekannter Befehlszeilenschalter X wurde übergangen)

Ein Schrägstrich (/) wurde in der Befehlszeile oder in einer Response-Datei entdeckt, ohne daß eine der erlaubten Optionen folgte.


@ seen, expected a response-files name
@ seen, expected a response-files name 	Bibliotheksmeldung

(Sonderzeichen @ erkannt, jedoch fehlt der Name der Response-Datei)

Der Name der Response-Datei folgt nicht unmittelbar auf das Sonderzeichen @.


Import 'symbol' in module `module' clashes with prior module
Import 'symbol' in module 'module' clashes with prior module 	Bibliotheksmeldung

(Importsymbol Symbol in Modul Modul kollidiert mit vorherigem Modul)

Ein Importsymbol darf in einer Bibliotheksdatei nur einmal vorkommen. Es soll ein Modul in die Bibliothek aufgenommen werden, das ein Importsymbol enthält, das bereits in einem anderen Modul der Bibliothek enthalten ist. Das Symbol kann nicht noch ein weiteres Mal aufgenommen werden.


`module' already in LIB, not changed!
'module' already in LIB, not changed! 	Bibliotheksmeldung

(Das Modul Modulname ist bereits in der Bibliotheksdatei enthalten, es wird nicht aktualisiert)

Diese Warnung verweist auf den Versuch, mit Hilfe der Option + ein Modul der Bibliothek hinzufügen, obwohl bereits eine Objekt-Datei desselben Namens Bestandteil der Bibliothek ist. Die Bibliothek wird nicht aktualisiert. Um diese Komponente zu aktualisieren, müßten Sie  die Option +- verwenden.


Bad GRPDEF type encountered, extended dictionary aborted
Bad GRPDEF type encountered, extended dictionary aborted 	Bibliotheksmeldung

(Fehlerhafte Typangabe in einem Record des Typs GRPDEF eines Objektmoduls gefunden. Der Versuch, ein erweitertes Verzeichnis anzulegen, wird abgebrochen)

Die Bibliotheksverwaltung hat einen ungültigen Eintrag in einem Datensatz mit einer Gruppendefinition (GRPDEF) in einem Objektmodul gefunden. Dieser Vorgang ereignete sich, während gerade ein erweitertes Verzeichnis angelegt wurde.

Die einzigen von der Bibliotheksverwaltung und dem Linker unterstützten Record-Typen GRPDEF sind segmentierte Indextypen. Falls die Bibiotheksverwaltung auf andere Arten von Datensätzen des Typs GRPDEF trifft, ist sie nicht mehr in der Lage, ein erweitertes Verzeichnis zu erzeugen. Es ist möglich, daß Objektmodule, die von Zusatzprogrammen anderer Hersteller als Borland erstellt wurden, Records des Typs GRPDEF eines anderen Typs enthalten. Diese Warnung wird auch erzeugt, wenn das Objektmodul zerstört worden ist.


Bad header in input LIB
Bad header in input LIB 	Bibliotheksmeldung

(Fehlerhafter Kopfteil in Biliothekendatei)

Beim Hinzufügen von Objektmodulen zu einer vorhandenen Bibliothek fand die Bibliotheksverwaltung fehlerhafte Daten im Kopfteil der Bibliothekendatei. Sie sollten die Bibliothek neu erstellen.


Can't grow LE/LIDATA record buffer
Can't grow LE/LIDATA record buffer 	Bibliotheksmeldung

(Puffer für Datensatz LE/LIDATA kann nicht vergrößert werden)

Fehler auf der Kommandozeilenebene.

Die Bibliotheksverwaltung versucht, einen Datensatz aus der Objekt-Datei zu lesen, ist aber nicht in der Lage, einen dafür passenden Speicherblock zu reservieren.

Falls das betreffende Modul ein oder mehrere große Datensegmente umfaßt, versuchen Sie, diesen Modul vorzuziehen und in der Reihenfolge vor anderen Modulen in die Bibliothek einzufügen.


Couldn't get LE/LIDATA record buffer
Couldn't get LE/LIDATA record buffer 	Bibliotheksmeldung

(Puffer für LE/LIDATA Datensatz kann nicht angelegt werden)

Fehler auf der Kommandozeilenebene.

Die Bibliotheksverwaltung versucht, einen Datensatz aus dem Objektmodul zu lesen, ist aber nicht in der Lage, einen dafür passenden Speicherblock zu reservieren.

Falls das betreffende Modul ein oder mehrere große(s) Datensegment(e) umfaßt, versuchen Sie, dieses Modul vorzuziehen und in der Reihenfolge vor anderen Modulen in die Bibliothek einzufügen.


Duplicate file `filename' in list, not added!
Duplicate file 'filename' in list, not added! 	Bibliotheksmeldung

(Name Dateiname eines Objektmoduls mehrfach in der Liste angegeben. Wird nicht hinzugefügt)

Beim Aufbau einer Bibliothek haben Sie in der Liste der einzufügenden Module einen Dateinamen mehr als einmal aufgeführt.

Fehler beim Ändern der Größe eines Dateipuffers.


Error changing file buffer size
Error changing file buffer size 	Bibliotheksmeldung

(Fehler beim Ändern der Größe eines Dateipuffers)

Die Bibliotheksverwaltung versucht, beim Lesen von einer bzw. Schreiben in eine Datei die Größe des zugeordneten Puffers anzupassen. Dafür fehlt jedoch ausreichender Speicherplatz. Sie werden mehr Speicherplatz freigeben müssen, um diesen Fehler zu beheben.


`filename' file not found
'filename' file not found 	Bibliotheksmeldung

(Datei Dateiname nicht gefunden)

Fehler auf der Kommandozeilenebene.

Die Bibliotheksverwaltung, aufgerufen von der Kommandozeile, versucht, ein nicht vorhandenes Objekt in eine Bibliothek einzufügen. Die Bibliotheksdatei wird auf jeden Fall angelegt.


Ignored `module', path is too long
Ignored 'module', path is too long 	Bibliotheksmeldung

(Modul Modulname wird ignoriert, da der Pfadname zu lang ist)

Der Pfadname einer Dateibezeichnung (Dateityp OBJ oder LIB) enthält mehr als die für die Bibliotheksverwaltung maximal zulässigen 64 Zeichen.


`module' not found in library
'module' not found in library 	Bibliotheksmeldung

(Modul Modulname nicht in Bibliothek gefunden)

Es wurde versucht, ein nicht vorhandenes Modul aus einer Bibliothek zu entfernen (-) oder aus einer Bibliothek zu extrahieren (*). Das angezeigte Objekt existierte nicht in der Bibliothek.


Record type `type' found, expected theadr or lheadr in module
Record type 'type' found, expected theadr or lheadr in 'module' 	Bibliotheksmeldung

(Record-Typ Typ des gefundenen Datensatzes in Modul entspricht nicht theadr oder lheadr, wie eigentlich erwartet.)

Die Bibliotheksverwaltung traf auf einen Datensatz mit unerwartetem Typ. Erwartet wurde in dem angegebenen Modul eigentlich ein Datensatz vom Typ theadr oder lheadr.


Unable to open 'filename' for output
Unable to open 'filename' for output 	Bibliotheksmeldung

(Datei Dateiname kann nicht für die Ausgabe geöffnet werden.)

Die Bibliotheksverwaltung kann die angegebene Ausgabedatei nicht öffnen. Das betrifft gewöhnlich die Zieldatei der neuen Bibliothek oder eines Listings und bezieht sich auf fehlenden Speicherplatz des verwendeten Laufwerkes.


Unable to rename 'filename1' to 'filename2'
Unable to rename 'filename1' to 'filename2' 	Bibliotheksmeldung

(Datei Dateiname1 kann nicht in Dateiname2 umbenannt werden.)

Die Bibliotheksverwaltung legt die neue Bibliothek zunächst in einer temporären Datei (Dateiname1) an und benennt diese temporäre Datei um in den eigentlichen Namen (Dateiname2) der Bibliothek. Diese Meldung erscheint, falls während dieser Umbenennung ein Fehler passiert, etwa ungenügend Platz auf der Festplatte.


Unexpected char X in command line
Unexpected char X in command line 	Bibliotheksmeldung

(Unerwartetes Zeichen X auf der Kommandozeile entdeckt.)

Die Bibliotheksverwaltung entdeckte einen Syntaxfehler beim Analysieren der Angaben der Kommandozeile.


Use /e with TLINK to obtain debug information from library
Use /e with TLINK to obtain debug information from library 	Bibliotheksmeldung

(Verwenden Sie den Schalter /e unter TLINK, um Debug-Information aus der Bibliothek zu gewinnen.)

Die Bibliothek wurde zusammen mit einem erweiterten Verzeichnis erstellt und enthält außerdem Debug-Information. TLINK kann nicht gleichzeitig Debug-Information extrahieren und sich dabei der erweiterten Verzeichnisse bedienen.

Um also Debug-Information für die ausführbare Programmdatei aus einer solchen Bibliothek zu gewinnen, müssen Sie den Schalter /e verwenden, damit der Linker die erweiterten Verzeichnisse ignoriert.

Anmerkung:	Der Linker der IDE unterstützt keine erweiterten Verzeichnisse. Es sind daher beim Linken innerhalb der IDE keine Änderungen an irgendwelchen Einstellungen nötig.


Ressourcen-Linker Fehlermeldungen und Warnungen

32-bit format in resource file 'filename'

Bad EXE header format in file

Bad EXE segment table in file

Error creating file

Error creating temporary file in directory

Error deleting file

Error getting size of file

Error in CURSDIR. Cannot find CURSOR

Error in EXE's resource table format

Error in FONTDIR. Cannot find FONT

Error in ICONDIR. Cannot find ICON

Error in packing preload area. Turn off preload packing

Error in RES format

Error in RES format. Cannot find NAMEDIR resource

Error in resource binary length (bad format?)

Error opening file

Error positioning file

Error reading file

Error renaming file

Error sizing file

Error writing file

Error. EXE alignment too small for packing resources too

Error. Expecting RES file, not EXE. File: <filename>

Error. Missing Name resource. RES not for Windows 3

Executable format not recognized in file

FONTDIR resource too big to link

FONTDIR too large to handle

Internal software error!

NAMEDIR resource too big to link

No resources

Not a Windows format EXE file

Out of memory!

Reporting error.

Resource format not recognized in file

Too many files to open

Too many resources to handle

Unsupported EXE RC version

Warning. Duplicate resources

Windows version is set to Win32, but target type is Win16.


Internal software error!
Internal software error! 	Ressourcen-Linker-Meldung

(Interner Programmfehler.)

Der Ressourcen-Linker stieß auf unerwartete Daten. Starten Sie den Ressourcen-Linker neu. Rufen Sie die Hotline von Borland Deutschland an, falls der Fehler immer noch auftritt.


Out of memory!
Out of memory! 	Ressourcen-Linker-Meldung

(Speicherüberlauf.)

Zum Compilieren einer bestimmten Datei steht nicht genügend Speicher zur Verfügung. In diesem Fall sollten Sie alle anderen Anwendungen schließen. Sie können auch versuchen, mehr Arbeitsspeicher zur Verfügung zu stellen oder die Quelltextdatei in kleinere Dateien aufteilen. Sie können auch die Datei auf einem Rechner mit mehr RAM-Speicher compilieren.


Bad EXE header format in file
Bad EXE header format in file. 	Ressourcen-Linker-Meldung

Auch: Executable format not recognized in file.

(Fehlerhafter Header-Bereich in EXE-Datei.)
(Auch: Unbekanntes Format in ausführbarer Datei.)

Im Kopfteil der ausführbaren Datei befinden sich ungültige Daten. Sie ist möglicherweise keine ausführbare Datei oder enthält zerstörte Daten.


Bad EXE segment table in file
Bad EXE segment table in file. 	Ressourcen-Linker-Meldung

(Fehlerhafte Segmenttabelle in EXE-Datei.)

In der Segmenttabelle der ausführbaren Datei befinden sich ungültige Informationen. Sie ist möglicherweise keine ausführbare Datei oder enthält zerstörte Daten.


Error in packing preload area. Turn off preload packing.
Error in packing preload area. Turn off preload packing. 	Ressourcen-Linker-Meldung

(Fehler im Preload-Bereich. Packen des Preload-Bereichs ausschalten.)

Ein Fehler trat auf, während der Ressourcen-Linker versuchte, die Anordnung der Ressourcen und Segmente in einer ausführbaren Datei zu optimieren (Dieser Fehler tritt nur in 16-Bit-Ressourcen auf.).

Lösung

Um den Fehler zu beheben, schalten Sie die Option Fastload-Bereich packen in den Ressourcen-Optionen aus.


Error creating file
Error creating file. 	Ressourcen-Linker-Meldung

(Fehler: Kann Datei nicht erzeugen.)

Ein Fehler trat auf, während der Ressourcen-Linker versuchte, eine Datei zu erzeugen. Dieser Fehler tritt auf, wenn das Arbeitslaufwerk voll oder schreibgeschützt ist. Er kann auch auftreten, wenn das Ausgabeverzeichnis nicht existiert.

Lösungen

Falls das Laufwerk voll ist, versuchen Sie, nicht benötigte Dateien zu löschen und starten den Ressourcen-Linker erneut.

Falls das Laufwerk schreibgeschützt ist, leiten Sie die Ausgaben auf ein beschreibbares Laufwerk um und starten den Ressourcen-Linker erneut.


Error creating temporary file in directory
Error creating temporary file in directory. 	Ressourcen-Linker-Meldung

(Fehler: Kann temporäre Datei im Verzeichnis nicht erzeugen.)

Ein Fehler trat auf, während der Ressourcen-Linker versuchte, eine temporäre Datei zu erstellen. Dieser Fehler tritt auf, wenn das Arbeitslaufwerk voll oder schreibgeschützt ist. Er kann auch auftreten, wenn das Ausgabeverzeichnis nicht existiert.

Lösungen

Falls das Laufwerk voll ist, versuchen Sie, nicht benötigte Dateien zu löschen und starten den Ressourcen-Linker erneut.

Falls das Laufwerk schreibgeschützt ist, leiten Sie die Ausgaben auf ein anderes Laufwerk um und starten den Ressourcen-Linker erneut.


Error deleting file
Error deleting file. 	Ressourcen-Linker-Meldung

(Fehler: Kann Datei nicht löschen.)

Ein Fehler trat auf, während der Ressourcen-Linker versuchte, eine Datei zu löschen. Dieser Fehler tritt auf, wenn die Datei als Nur-Lesen markiert ist oder nicht existiert.

Lösung

Falls die Datei als Nur-Lesen markiert ist, ändern Sie ihre Attribute, so daß die Datei gelöscht werden kann.


Error in CURSDIR. Cannot find CURS
Error in CURSDIR. Cannot find CURS. 	Ressourcen-Linker-Meldung

(Fehler im Cursor-Verzeichnis. Kann CURS nicht finden.)

Im Cursor-Verzeichnis wurde ein Eintrag gefunden, der zu keiner Cursor-Ressource gehört. Die Ressourcendatei ist möglicherweise zerstört.


Error in EXE's resource table format
Error in EXE's resource table format. 	Ressourcen-Linker-Meldung

(Formatfehler in Ressourcentabelle der EXE-Datei.)

Ungültige Ressourcen-Tabelle in der ausführbaren Datei. Die ausführbare Datei könnte entweder ungültige Ressourcen-Informationen enthalten oder sie ist zerstört.


Error in FONTDIR. Cannot find FONT
Error in FONTDIR. Cannot find FONT. 	Ressourcen-Linker-Meldung

(Fehler im Schriftenverzeichnis. Kann Schrift nicht finden.)

Im Schriftenverzeichnis wurde ein Eintrag gefunden, der zu keiner Schrift-Ressource gehört. Die Ressourcendatei ist möglicherweise zerstört.


Error in ICONDIR. Cannot find ICON
Error in ICONDIR. Cannot find ICON. 	Ressourcen-Linker-Meldung

(Fehler im Symbolverzeichnis. Kann Symbol nicht finden.)

Im Symbolverzeichnis wurde ein Eintrag gefunden, der zu keiner Symbol-Ressource gehört. Die Ressourcendatei ist möglicherweise zerstört.


Error in RES format
Error in RES format. 	Ressourcen-Linker-Meldung

(Formatfehler in RES-Datei.)

Ungültige Informationen in der binären Ressourcendatei. Die Ressourcendatei könnte ungültige Ressourcen-Informationen enthalten oder ist möglicherweise zerstört. Versuchen Sie, die Ressourcen nochmal zu compilieren und starten Sie den Ressourcen-Linker erneut.


Error in RES format. Cannot find NAMEDIR resource
Error in RES format. Cannot find NAMEDIR resource. 	Ressourcen-Linker-Meldung

(Fehler im Format RES. Kann Ressource NAMEDIR nicht finden.)

Ein Eintrag in der NAME-Tabelle wurde gefunden, der keine zugehörige Ressource hat. Überprüfen Sie, ob die passende Ressource in Ihrem Ressourcen-Script eingetragen ist. NAME-Tabellen werden für Windows 3.1 oder höher nicht verwendet.


Error in resource binary length (bad format?)
Error in resource binary length (bad format?). 	Ressourcen-Linker-Meldung

(Fehler in Länge der binären Ressource (ungültiges Format?).)

Fehler in der Größe einer binären Ressource. Das Format der Ressource könnte ungültig sein oder die Ressource ist zerstört.


Error in STRINGTABLE format
Error in STRINGTABLE format. 	Ressourcen-Linker-Meldung

(Formatfehler in STRINGTABLE.)

Der Ressourcen-Linker (RLINK) sollte diese Meldung nicht ausgeben!


Error making absolute file name
Error making absolute file name. 	Ressourcen-Linker-Meldung

(Fehler: Kann absoluten Dateinamen nicht erstellen.)

Der Ressourcen-Linker (RLINK) sollte diese Meldung nicht ausgeben!


Error opening file
Error opening file. 	Ressourcen-Linker-Meldung

(Fehler: Kann Datei nicht öffnen.)

Ein Fehler trat auf, während der Ressourcen-Linker versuchte, eine Datei zu öffnen. Dieser Fehler tritt auf, wenn die Datei nicht existiert, ein anderer Prozeß den Zugriff auf die Datei gesperrt hat, das Verzeichnis oder der Dateiname falsch ist oder wenn keine Datei-Handles mehr zur Verfügung stehen.


Error positioning file
Error positioning file. 	Ressourcen-Linker-Meldung

(Positionierfehler in Datei.)

Ein Fehler trat während des Versuchs auf, eine Stelle in einer Datei zu suchen. Diese Datei könnte abgeschnitten oder zerstört sein. Versuchen Sie, mit Hilfe von CHKDSK die Laufwerksintegrität zu überprüfen oder compilieren Sie die Ressourcendateien nochmal und starten Sie den Ressourcen-Linker erneut.


Error positioning file
Error positioning file. 	Ressourcen-Linker-Meldung

(Positionierfehler in Datei.)

Der Ressourcen-Linker (RLINK) sollte diese Meldung nicht ausgeben!


Error reading file
Error reading file. 	Ressourcen-Linker-Meldung

(Fehler beim Lesen in einer Datei.)

Ein Fehler trat auf, während der Ressourcen-Linker versuchte, eine Datei zu lesen. Dieser Fehler ereignet sich typischerweise dann, wenn während des Lesens einer Datei ein Laufwerkfehler auftritt.


Error renaming file
Error renaming file. 	Ressourcen-Linker-Meldung

(Fehler beim Umbenennen einer Datei.)

Ein Fehler trat auf, während der Ressourcen-Linker versuchte, eine Datei umzubenennen. Dieser Fehler ereignet sich, wenn die Datei als Nur-Lesen markiert ist oder nicht existiert oder wenn bereits eine Datei mit dem Namen besteht, die der Ressourcen-Linker zu benutzen versucht,.

Lösungen

Falls die Datei als Nur-Lesen markiert ist, ändern Sie ihre Attribute, so daß die Datei gelöscht werden kann.

Falls eine Datei mit dem Namen bereits besteht, können Sie entweder diese Datei löschen oder einen anderen Namen wählen.


Error sizing file
Error sizing file. 	Ressourcen-Linker-Meldung

Auch: Error getting size of file.

(Fehler bei Dateigrößenbestimmung.)
(Auch: Fehler bei der Ermittelung der Dateigröße.)

Ein Laufwerksfehler trat bei bei dem Versuch auf, die Dateigröße zu bestimmen.


Error writing file
Error writing file. 	Ressourcen-Linker-Meldung

(Schreibfehler in eine Datei.)

Ein Fehler trat auf, während der Ressourcen-Linker versuchte, in eine Datei zu schreiben. Dieser Fehler tritt auf, wenn das Arbeitslaufwerk voll oder schreibgeschützt ist.

Lösungen

Falls das Laufwerk voll ist, versuchen Sie, nicht benötigte Dateien zu löschen und den Ressourcen-Linker erneut zu starten.

Falls das Laufwerk schreibgeschützt ist, leiten Sie die Ausgaben auf ein anderes Laufwerk um und starten den Ressourcen-Linker erneut.


Error. EXE alignment too small for packing resources too
Error. EXE alignment too small for packing resources too. 	Ressourcen-Linker-Meldung

(Fehler: Ausrichtungen sind zu klein für komprimierte Ressourcen.)

Die Option zum Packen des Preload-Bereiches ist eingeschaltet und die Ressourcen passen nicht zu den momentanen Ausrichtungsabbildungen. Versuchen Sie, den Wert für die Ausrichtungen zu erhöhen, linken Sie nochmal und starten Sie den Ressourcen-Linker erneut.


Error. Missing Name resource. RES not for Windows 3
Error. Missing NAME resource. RES not for Windows 3. 	Ressourcen-Linker-Meldung

(Fehler: Resource NAME fehlt. RES-Datei ist nicht für Windows 3.x)

Der binären Ressource fehlt die Ressource NAME. Die Ressourcendatei ist möglicherweise keine Ressourcendatei für Windows 3.


FONTDIR resource too big to link
FONTDIR resource too big to link. 	Ressourcen-Linker-Meldung

Auch: FONTDIR too large to handle.

(Ressource FONTDIR ist zu groß zum Linken.)
(Auch: Ressource FONTDIR ist zu groß zum Bearbeiten.)

Die Größe des Verzeichnisses der Schrifttabellen ist überschritten worden. Versuchen Sie, die Schriftarten auf mehrere FON-Dateien aufzuteilen.


NAMEDIR resource too big to link
NAMEDIR resource too big to link. 	Ressourcen-Linker-Meldung

(Ressource NAMEDIR ist zu groß zum Linken.)

Die maximale Größe der Tabelle NAME ist überschritten worden. Einträge in die Tabelle NAME werden in Windows 3.1 oder höher nicht verwendet.


Not a Windows format EXE file
Not a Windows format EXE file. 	Ressourcen-Linker-Meldung

(Keine .EXE-Datei von Windows.)

Die ausführbare Datei, in die Sie Ressourcen einzubinden versuchen, ist keine gültige Windows- oder Win32-Datei.


Program execution arrived at yet-to-be-written code
Program execution arrived at yet-to-be-written code. 	Ressourcen-Linker-Meldung

(Programmausführung an noch zu schreibenden Code angelangt.)

Der Ressourcen-Linker (RLINK) sollte diese Meldung nicht ausgeben!


Resultant EXE size too big
Resultant EXE size too big. 	Ressourcen-Linker-Meldung

(Resultierende EXE-Dateigröße zu groß.)

Der Ressourcen-Linker (RLINK) sollte diese Meldung nicht ausgeben!


Too many files to open
Too many files to open. 	Ressourcen-Linker-Meldung

(Zuviele geöffnete Dateien.)

Sie haben das Dateilimit des Ressourcen-Linkers überschritten. Versuchen Sie, einzelne Ressourcendateien in eine einzige Ressource zusammenzufügen.


Too many resources to handle
Too many resources to handle. 	Ressourcen-Linker-Meldung

(Zuviele Ressourcen zu verwalten.)

Sie haben mehr Ressourcen angegeben, als der Ressourcen-Linker verwalten kann. Versuchen Sie, die Gesamtanzahl der Ressourcen, die Sie zu linken versuchen, zu verringern.


Too many STRINGTABLEs to link
Too many STRINGTABLEs to link. 	Ressourcen-Linker-Meldung

(Zuviele STRINGTABLEs zu linken.)

Der Ressourcen-Linker (RLINK) sollte diese Meldung nicht ausgeben!

Sie haben mehr String-Tabellen angegeben, als der Ressourcen-Linker verarbeiten kann. Versuchen Sie, die gesamte Anzahl der String-Tabellen zu verringern.


Unsupported EXE RC version
Unsupported EXE RC version. 	Ressourcen-Linker-Meldung

(Nicht unterstützte RC-Version in EXE-Datei.)

Sie versuchen Ressourcen in eine ausführbare Datei zu linken, die bereits Ressourcen eingebunden hat. Die Versionsnummern dieser Ressourcen können von diesem Ressourcen-Linker nicht erkannt werden. Versuchen Sie, die Ressourcen zu entfernen oder linken Sie diese nochmal.


Resource file is 32-bit format. Please recompile.
32-bit format in resource file. Please recompile. 	Ressourcen-Linker-Meldung

(32-Bit-Format in Ressourcendatei. Neu compilieren.)

Sie versuchen eine compilierte Ressourcendatei (RES-Datei) in Ihrer Anwendung zu verwenden, die 32-Bit-Ressourcen enthält. Der Zieltyp Ihrer Anwendung ist jedoch 16-Bit-Windows. Compilieren Sie die Ressourcendatei für Windows 3.1, oder ändern Sie den Zieltyp für Ihre Anwendung nach Win32.


Reporting error.
Reporting error. 	Ressourcen-Linker-Meldung

(Problem bei der Fehlerausgabe)

Der Ressourcen-Linker stieß auf ein Problem während des Versuchs, einen Fehler auszugeben.


Error. Expecting RES file, not EXE. File: <filename>
Error. Expecting RES file, not EXE. File: <filename> 	Ressourcen-Linker-Meldung

(Fehler: RES-Datei erwartet, nicht EXE-Datei. Datei: <Dateiname>.)

Der Ressourcen-Linker hat eine compilierte Ressourcendatei (RES-Datei) erwartet, fand jedoch stattdessen eine ausführbare Datei (EXE-Datei). Überprüfen Sie, ob Sie die richtigen Knoten und Dateitypen angegeben haben.


Windows version is set to Win32, but target type is Win16.
Windows version is set to Win32, but target type is Win16. 	Ressourcen-Linker-Meldung

(Windows-Version auf Win32 eingestellt, Zieltyp ist aber Win16.)

Die Version für Ihre Ressourcen ist auf Win32 eingestellt, aber der Zieltyp Ihres Projektes ist für eine 16-Bit-Windows-Anwendung. 16-Bit-Windows-Anwendungen können keine 32-Bit-Ressourcen verwenden.

Ändern Sie entweder die Version Ihrer Ressourcen auf Windows 3.1 oder ändern Sie den Zieltyp Ihrer Anwendung auf Win32.


Warning. Duplicate resources.
Warning. Duplicate resources. 	Ressourcen-Linker-Meldung

(Warnung: Doppelte Ressourcen vorhanden.)

Wenn mehrere Ressourcendateien zum einem Programm zusammengebunden werden, kann es vorkommen, daß in den Dateien Ressourcen doppelt vorhanden sind. So könnten Sie zum Beispiel das gleiche Symbol in zwei verschiedenen RES-Dateien verwenden. Der Ressourcen-Linker markiert dies und entfernt die zweite Ressource.

Anmerkung:	Die Ressourcen müssen vom gleichen Typ sein und die gleichen Bezeichner haben, um zu Duplikaten erklärt zu werden.


No resources.
No resources. 	Ressourcen-Linker-Meldung

(Keine Ressourcen.)

Diese Warnung erscheint, wenn dem Linker eine leere Ressourcendatei übergeben wird.


Error seeking point in file.
Error seeking point in file. 	Ressourcen-Linker-Meldung

(Fehler suchen nach einer Stelle in einer Datei.)

Bei dem Versuch, eine bestimmte Stelle in einer Datei zu finden ist ein Fehler aufgetreten. Die Datei könnte abgeschnitten oder beschädigt sein. Versuchen Sie, die Dateien zu compilieren und starten Sie anschließend den Link der Ressourcen erneut.


Resource format not recognized in file.
Resource format not recognized in file. 	Ressourcen-Linker-Meldung

(Format in Ressourcendatei nicht erkannt.)

Die RES-Datei, die Sie gerade verwenden wollen, enthält eine Ressource unbekannten Formats. Normalerweise ist dieser Fehler auf eine beschädigte Ressourcendatei zurückzuführen. Prüfen Sie, ob Sie eine gültige Ressourcendatei einbinden und erstellen Sie diese nötigenfalls neu.


`filename' does not existdon't know how to make it
'filename' does not exist: don't know how to make it	MAKE-Meldung

(Datei Dateiname nicht vorhanden. Make verfügt über kein Wissen, diese Datei zu erzeugen.)

Die Generierungsfolge enthält den Namen einer nicht vorhandenen Datei, für die allerdings keine Regel bekannt ist, aus der sich der Dateiname erzeugen ließe.


Unable to execute command: 'command'
Unable to execute command: 'command' 	MAKE-Meldung

(Befehl Befehl kann nicht ausgeführt werden.)

Ein Befehl konnte nicht ausgeführt werden. Mögliche Gründe dafür sind: die entsprechende Programmdatei konnte nicht gefunden werden, ein falscher Programmname wurde verwendet, es fehlte an Speicherplatz für den Auslagerungsbereich auf der Festplatte, das Verzeichnis des Auslagerungsbereichs existierte nicht oder die Programmdatei ist vorhanden, aber zerstört. Der letzte Fall ist wohl weniger wahrscheinlich.


Incorrect command line argument: 'argument'
Incorrect command line argument: 'argument' 	MAKE-Meldung

(Ungültiges Argument Argument auf der Kommandozeile verwendet.)

Sie haben in der Kommandozeile ungültige Argumente verwendet. Geben Sie den Befehl erneut ein und korrigieren Sie die fehlerhaften Argumente.


Unable to open makefile
Unable to open makefile 	MAKE-Meldung

(Make-Datei kann nicht geöffnet werden.)

Das aktuelle Verzeichnis enthält keine Datei des Namens MAKEFILE oder MAKEFILE.MAK, bzw. es kennt keine Datei des Namens, den Sie mit Hilfe der Option -f in der Kommandozeile angegeben haben.


Not enough memory
Not enough memory 	MAKE-Meldung

(Nicht genügend Speicherplatz)

Ihr gesamter Arbeitsspeicher ist in Benutzung.


Error directive: 'message'
Error directive: 'message' 	MAKE-Meldung

(Fehler-Anweisung: Meldung)

MAKE hat eine Anweisung #error der Make-Datei bearbeitet und den Text der Anweisung als Meldung ausgegeben.


Unable to redirect input or output
Unable to redirect input or output 	MAKE-Meldung

(Eingabe oder Ausgabe konnte nicht umgeleitet werden.)

MAKE war nicht in der Lage, die für das Umleiten von Eingabe oder Ausgabe benötigten temporären Dateien zu öffnen. Sollten Sie in einer Netzwerkumgebung arbeiten, so achten Sie bitte darauf, daß Ihnen die Zugriffsrechte für das jeweilige Arbeitsverzeichnis zur Verfügung stehen.


No terminator specified for in-line file operator
No terminator specified for in-line file operator 	MAKE-Meldung

(Abschließendes Zeichen für den Operator der Inline-Datei fehlt.)

Die Make-Datei enthält die Inline-Operatoren && oder <<, aber die damit eingeleiteten Inline-Dateien sind nicht mit dem entsprechenden Zeichen abgeschlossen.


Circular dependency exists in makefile
Circular dependency exists in makefile 	MAKE-Meldung

(Zirkuläre Abhängigkeit in der Make-Datei.)

Die Make-Datei zeigt an, daß eine Datei auf dem aktuellen Stand sein muß, bevor sie neu erzeugt werden kann. Betrachten Sie beispielweise die folgenden expliziten Regelangaben:

filea:  fileb

fileb:  filec

filec:  filea

Daraus folgt, daß filea von fileb, fileb von filec, und filec wiederum von filea abhängen. Dieser Zusammenhang ist unzulässig, da eine Datei weder direkt noch indirekt von sich selbst abhängen darf.


Macro substitute text 'string' is too long
Macro substitute text 'string' is too long 	MAKE-Meldung

(Makro-Ersetzungstext String ist zu lang.)

Der in einer Makrodefinition enthaltende Text String führte zum Überlauf des internen Puffers von MAKE. Dieser Puffer umfaßt 512 Bytes.


Macro replace text 'string' is too long
Macro replace text 'string' is too long 	MAKE-Meldung

(Makro-Ersetzungstext String ist zu lang.)

Der in einer Makrodefinition enthaltende ersetzende Text String führte zum Überlauf des internen Puffers von MAKE. Dieser Puffer umfaßt 512 Bytes.


'%s' - ')' missing in macro invocation
'macroname' - ')' missing in macro invocation 	MAKE-Meldung

(Das Makro Makroname wurde beim Aufruf ohne schließende runde Klammer verwendet.)

Der von Ihnen benutzte Makro-Aufruf enthält keine schließende runde Klammer.


Cycle in include files: 'filename'
Cycle in include files: 'filename' 	MAKE-Meldung

(Zirkuläre Einbindung in Make-Datei Dateiname.)

Diese Fehlermeldung wird ausgegeben, wenn eine Make-Datei sich selbst (direkt oder indirekt) versucht einzubinden.


FATAL ERROR: GP FAULT
FATAL ERROR: GP FAULT 	MAKE-Meldung

(Schwerwiegender Fehler: Allgemeine Schutzverletzung.)

Ihr Programm verursachte eine sogenannte allgemeine Schutzverletzung und endete mit einem schwerwiegenden Fehler. Es gibt unterschiedliche Ursachen solcher Fehler, etwa der Versuch, an eine unzulässige Stelle im Speicher zu schreiben. Um den Fehler zu lokalisieren, sollten Sie am besten das Programm CodeGuard einsetzen.


Cannot write a string option
Cannot write a string option 	MAKE-Meldung

(String-Option kann nicht geschrieben werden.)

Die MAKE-Option -W sichert eine Zeichenoption in der Datei MAKE.EXE. Falls eine String-Option existiert, wird diese Fehlermeldung erzeugt. So führt beispielweise die folgende String-Option zu der Fehlermeldung:

–Dxxxx="My_foo" oder –Uxxxxx


Cannot find MAKE.EXE
Cannot find MAKE.EXE 	MAKE-Meldung

(MAKE.EXE kann nicht gefunden werden.)

Die Programmdatei MAKE.EXE, aufrufbar von der Kommandozeile, kann nicht gefunden werden. Stellen Sie sicher, daß diese Datei sich im aktuellen Verzeichnis befindet bzw. sich über die Verzeichnisangaben der Umgebungsvariablen PATH finden läßt.


Unable to open file 'filename'
Unable to open file 'filename' 	MAKE-Meldung

(Datei Dateiname kann nicht geöffnet werden.)

Dieser Fehler läßt sich auf nicht vorhandene oder mit inkorrektem Namen angegebene Dateien zurückführen.


'filename' not a MAKE
'filename' not a MAKE 	MAKE-Meldung

(Datei Dateiname ist keine Make-Datei.)

Die mit der Option -f angegebene Datei ist keine Make-Datei.


Write error on file 'filename'
Write error on file 'filename' 	MAKE-Meldung

(Fehler beim Schreiben in die Datei Dateiname.)

MAKE konnte die in der Make-Datei angegebene Datei nicht öffnen oder nicht in sie schreiben. Sie sollten dafür sorgen, daß genügend Platz auf der Festplatte vorhanden ist und daß Sie Schreibrechte für diese Festplatte besitzen.


Command arguments too long
Command arguments too long 	MAKE-Meldung

(Argumentliste des Befehls zu lang.)

Die Argumentliste eines Befehls umfaßt mehr als die von DOS zugelassenen 511 Zeichen.


Unexpected end of file in conditional started at line 'line number'
Unexpected end of file in conditional started at line 'line number' 	MAKE-Meldung

(Unerwartetes EOF in Verbindung mit einer bedingten Anweisung in Zeile Zeilennummer.)

Die Make-Datei endet, ohne daß MAKE ein fehlendes !endif gefunden hat. Entweder fehlt diese !endif-Anweisung oder sie ist fehlerhaft geschrieben.


Unknown preprocessor statement
Unknown preprocessor statement 	MAKE-Meldung

(Unbekannte Präprozessor-Anweisung.)

Ein Ausrufezeichen (!) wurde am Anfang einer Zeile gefunden, und der dahinter folgende Name war nicht gültig (also nicht: error, undef, if, elif, include, else, endif).


Bad filename format in include statement
Bad filename format in include statement 	MAKE-Meldung

(Fehlerhafter Dateiname in include-Anweisung.)

Namen von Dateien, die mit einer include-Anweisung eingebunden werden, müssen in Anführungszeichen oder spitze Klammern eingeschlossen sein. Dem gegebenen Dateinamen fehlte zumindest die öffnende spitze Klammer bzw. das erste Anführungszeichen.


Filename too long
Filename too long 	MAKE-Meldung

(Dateiname zu lang.)

Der in einer !include-Anweisung angegebene Pfadname führte zu einem Überlauf des internen, 512 Bytes langen Puffers von MAKE.


No filename ending
No filename ending 	MAKE-Meldung

(Fehlender Abschluß eines Dateinamens.)

Der in einer include-Anweisung verwendete Dateiname ist ohne abschließende spitze Klammer bzw. ohne abschließendes Anführungszeichen.


Unable to open include file 'filename'
Unable to open include file 'filename 	MAKE-Meldung '

(Datei Dateiname einer Anweisung include konnte nicht geöffnet werden.)

Der Compiler konnte die Datei mit dem angegebenen Namen nicht finden. Es kann aber auch sein, daß die einzubindende Datei versucht, sich selbst einzubinden. Eine weitere mögliche Ursache ist das Fehlen des Parameters FILES in der Datei CONFIG.SYS (z.B. FILES=20) Ihres Wurzelverzeichnisses. Prüfen Sie, ob die angegebene Datei existiert.


Macro expansion too long
Macro expansion too long 	MAKE-Meldung

(Makroerweiterung ist zu lang.)

Ein Makro kann durch Substitution nicht mehr als 4096 Zeichen umfassen. Dieser Fehler tritt oft auf, wenn ein Makro sich selbst rekursiv erweitert. Es ist unzulässig, daß sich ein Makro selbst erweitert.


If statement too long
If statement too long 	MAKE-Meldung

(if-Anweisung zu lang.)

Eine If-Anweisung umfaßt mehr als 4.096 Zeichen.


Rule line too long
Rule line too long 	MAKE-Meldung

(Regel zu lang.)

Eine direkte oder indirekte Regel umfaßt mehr als 4.096 Zeichen.


Bad undef statement syntax
Bad undef statement syntax 	MAKE-Meldung

(Fehlerhafte Syntax einer undef-Anweisung.)

Eine !undef-Anweisung darf nur einen einzigen Bezeichner enthalten und nicht größer als der Rumpf Anweisung selbst sein.


Misplaced else statement
Misplaced else statement 	MAKE-Meldung

(else-Anweisung ohne entsprechende if-Anweisung.)

Einer !else-Anweisung fehlt die entsprechende !if-Anweisung.


Command syntax error
Command syntax error 	MAKE-Meldung

(Syntaxfehler bei Befehlsangabe)

Diese Meldung erscheint, wenn:

die erste Zeile der Make-Datei mit einer Regel irgendwelche führenden Whitespace-Zeichen enthält..

eine implizite Regel nicht dem Schema .ext.ext: entspricht.

eine explizite Regel keinen Namen vor dem Doppelpunkt (:) enthält.

eine Makrodefinition keinen Namen vor dem Gleichheitszeichen (=) enthält.


Misplaced elif statement
Misplaced elif statement 	MAKE-Meldung

(elif-Anweisung ohne entsprechende if-Anweisung.)

Einer !elif-Anweisung fehlt die entsprechende !if-Anweisung.


Misplaced endif statement
Misplaced endif statement 	MAKE-Meldung

(endif-Anweisung ohne entsprechende if-Anweisung.)

Einer !endiff-Anweisung fehlt die entsprechende !if-Anweisung.


Illegal character in constant expression 'expression'
Illegal character in constant expression 'expression' 	MAKE-Meldung

(Ungültiges Zeichen in dem Konstantenausdruck Ausdruck.)

MAKE fand ein ungültiges Zeichen in einem Konstantenausdruck. Wenn dieses Zeichen ein Buchstabe war, so handelt es sich vermutlich um einen fehlerhaft geschriebenen Bezeichner.


Expression syntax error in !if statement
Expression syntax error in !if statement 	MAKE-Meldung

(Syntaxfehler in einem Ausdruck einer !if-Anweisung.)

Der Ausdruck einer !if-Anweisung ist fehlerhaft. Der Grund dafür ist eine deplazierte Klammer, ein Operator zuviel bzw. zuwenig oder eine Konstante zuviel bzw. zuwenig


Illegal octal digit
Illegal octal digit 	MAKE-Meldung

(Ungültige oktale Ziffer.)

Eine oktale Konstante enthält eine ungültige Ziffer (z.B. 8 oder 9).


Character constant too long
Character constant too long 	MAKE-Meldung

(Zeichenkonstante zu lang.)

Eine Zeichenkonstante in einem Ausdruck ist zu lang.


Division by zero
Division by zero 	MAKE-Meldung

(Division durch Null.)

Ein Ausdruck enthält in einer arithmetischen Division oder in einem Rest einen Divisor mit dem Wert 0.


Redefinition of target 'filename'
Redefinition of target 'filename' 	MAKE-Meldung

(Neudefinition der Zieldatei Dateiname.)

Der angegebene Dateiname erscheint öfter als einmal auf der linken Seite einer expliziten Regel.


Bad macro output translator
Bad macro output translator 	MAKE-Meldung

(Fehler bei der Übersetzung der Makroausgabe.)

Syntaxfehler bei der Substitution innerhalb eines Makros.


Too many suffixes in .SUFFIXES list
Too many suffixes in .SUFFIXES list 	MAKE-Meldung

(Zu viele Suffixe in der Liste .SUFFIXES)

Die Liste der Suffixe kann bis zu 255 Suffixe enthalten.


Use of : and :: dependents for target 'target'
Use of : and :: dependents for target 'target' 	MAKE-Meldung

(Zieldatei in Kombination mit Abhängigkeiten zweierlei Typen: : und ::)

Sie versuchen, die Zieldatei in Verbindung mit einfachen (:) und mehrfachen (::) Abhängigkeiten zu bringen. Zum Beispiel:

filea:   fileb

filea::  filec


Ifdef statement too long
Ifdef statement too long 	MAKE-Meldung

(ifdef-Anweisung zu lang.)

Eine !ifdef-Anweisung umfaßt mehr als 4.096 Zeichen.


Ifndef statement too long
Ifndef statement too long 	MAKE-Meldung

(ifndef-Anweisung zu lang.)

Eine !ifndef-Anweisung umfaßt mehr als 4.096 Zeichen.


No match found for wildcard 'expression'
No match found for wildcard 'expression' 	MAKE-Meldung

(Kein Gegenstück für Ausdruck mit Jokerzeichen gefunden.)

Für den Ausdruck mit Jokerzeichen, den Sie von MAKE expandieren ließen, konnte keine Datei mit einem passenden Namen gefunden werden. So wird zum Beispiel der folgende Ausdruck zu einer solchen Fehlermeldung führen, falls das aktuelle Verzeichnis keine OBJ-Dateien enthält:

prog.exe: *.obj


No closing quote
No closing quote 	MAKE-Meldung

(Fehlende Anführungszeichen am Ende.)

Ein als String auszuwertender Ausdruck wird in einem !if- oder !elif-Ausdruck nicht mit Anführungszeichen abgeschlossen.


String type not allowed with this operand
String type not allowed with this operand 	MAKE-Meldung

(Strings sind mit diesem Operandentyp nicht vergleichbar.)

Sie verwenden einen Operandentyp, der nicht Teil eines Vergleiches mit einem String sein kann. Gültige Operanden sind  (==, !=, <, >, <=, >=).


Int and string types compared
Int and string types compared 	MAKE-Meldung

(String und Integer wurden miteinander verglichen.)

Sie vergleichen einen Integerwert mit einem String in einem Ausdruck des Typs !if bzw. !elif.


Colon expected
Colon expected 	MAKE-Meldung

(Doppelpunkt wurde erwartet.)

Einer impliziten Regel fehlt der Doppelpunkt am Ende.

.c.obj:	# Richtig

.c.obj	# Falsch


Only <<KEEP or <<NOKEEP
Only <<KEEP or <<NOKEEP 	MAKE-Meldung

(Es gilt nur <<KEEP oder <<NOKEEP.)

Sie haben beim Schließen einer temporären Inline-Datei innerhalb der Make-Datei eine ungültige Angabe gemacht. Zugelassen sind nur <<KEEP bzw. <<NOKEEP.


Unexpected end of file
Unexpected end of file 	MAKE-Meldung

(Unerwartetes Dateiende (EOF, End Of File).)

Das Ende der Make-Datei wurde erreicht, bevor eine temporäre Inline-Datei geschlossen wurde.


Cannot have path list for target
Cannot have path list for target 	MAKE-Meldung

(Zieldatei kann keine Liste von Pfadnamen haben.)

Sie können eine Liste von Pfadnamen nur für die Dateien auf der rechten Seite einer expliziten Regel angeben. Das folgende Beispiel zeigt eine gültige wie auch eine ungültige Liste von Pfadnamen:

{Pfad1;Pfad2}prog.exe: prog.obj	 # Ungültig

prog.exe: {Pfad1;Pfad2}prog.obj	 # Gültig


Cannot have multiple paths for implicit rule
Cannot have multiple paths for implicit rule 	MAKE-Meldung

(Keine mehrfachen Pfadnamen in einer impliziten Regel.)

Sie können nur einen Pfadnamen für jede der Namenserweiterungen einer impliziten Regel angeben, z.B. {Pfad}.c.obj. Listen mit mehreren Pfadnamen sind nur bei den Dateien auf der rechten Seite einer expliziten Regel erlaubt.


No macro before =
No macro before = 	MAKE-Meldung

(Kein Makro-Aufruf vor dessen Definition.)

Sie müssen ein Makro definieren (benennen), bevor Sie ihm einen Wert zuweisen.


Too many rules for target 'target'
Too many rules for target 'target' 	MAKE-Meldung

(Zuviele Regeln für die Zieldatei.)

MAKE ist nicht in der Lage, die zur Erzeugung der Zieldatei nötigen Regeln zu bestimmen, da es zuviele Regeln für diese Zieldatei gibt. Folgende Konstellation in einer Make-Datei führt z.B. zu einer solchen Fehlermeldung:

abc.exe : a.obj

bcc -c a.c

abc.exe : b.obj

abc.exe : c.obj

bcc -c b.c c.c


Illegal/invalid option in CMDSWITCHES directive `directive'
Illegal/invalid option in CMDSWITCHES directive 'option' 	MAKE-Meldung

(Unzulässige Option in der Präprozessoranweisung Option vom Typ CMDSWITCHES.)

Die Präprozessoranweisung !CMDSWITCHES erlaubt es, eine oder mehrere Optionen der Kommandozeile ein- bzw. auszuschalten. Die Syntax dafür sieht das Pluszeichen (+) für den ersten, das Minuszeichen (-) für den letzten Fall vor. In beiden Fällen folgen ein oder mehrere Buchstaben, die für jeweils eine bestimmte Option stehen. Die Fehlermeldung hier bezieht sich auf solch eine ungültige Optionsangabe.


Unknown CMDSWITCHES operator 'operator'
Unknown CMDSWITCHES operator 'operator' 	MAKE-Meldung

(Unzulässiger Operator in der Präprozessoranweisung CMDSWITCHES.)

Die Präprozessoranweisung !CMDSWITCHES erlaubt es, eine oder mehrere Optionen der Kommandozeile ein- bzw. auszuschalten. Die Syntax dafür sieht das Pluszeichen (+) für den ersten, das Minuszeichen (-) für den letzten Fall vor. In beiden Fällen folgen ein oder mehrere Buchstaben, die für jeweils eine bestimmte Option stehen. Die Fehlermeldung hier bezieht sich auf ein ungültiges Operatorzeichen (also nicht: + oder -).


Fehlermeldungen von MAKE

Im folgenden werden die Fehlermeldungen aufgeführt, die bei der Verwendung des Programmes MAKE auftreten können:

Bad filename format in include statement

Bad macro output translator

Bad undef statement syntax

Cannot find MAKE.EXE

Cannot have multiple paths for implicit rule

Cannot have path list for target

Cannot write a string option

Character constant too long

Circular dependency exists in makefile

Colon expected

Command arguments too long

Command syntax error

Cycle in include files: 'filename'

Division by zero

Error directive: 'message'

Expression syntax error in !if statement

FATAL ERROR: GP FAULT

filename' does not existdon't know how to make it

'filename' not a MAKE

Filename too long

If statement too long

Ifdef statement too long

Ifndef statement too long

Illegal character in constant expression 'expression'

Illegal octal digit

Illegal/invalid option in CMDSWITCHES directive 'option'

Incorrect command line argument:

Int and string types compared

Macro expansion too long

Macro replace text 'string' is too long

Macro substitute text 'string' is too long

'macroname'—')' missing in macro invocation

Misplaced elif statement

Misplaced else statement

Misplaced endif statement

No closing quote

No filename ending

No macro before =

No match found for wildcard 'expression'

No terminator specified for in-line file operator

Not enough memory

Only <<KEEP or <<NOKEEP

Redefinition of target 'filename'

Rule line too long

String type not allowed with this operand

Too many rules for target 'target'

Too many suffixes in .SUFFIXES list

Unable to execute command: 'command'

Unable to open file 'filename'

Unable to open include file 'filename'

Unable to open makefile

Unable to redirect input or output

Unexpected end of file in conditional started at line 'line number'

Unexpected end of file

Unknown CMDSWITCHES operator 'operator'

Unknown preprocessor statement

Use of : and :: dependents for target 'target'

Write error on file 'filename'


Fehlermeldungen und Warnungen des Resource Workshop

Klicken Sie hier, um eine alphabetische Liste aller Fehlermeldungen des Resource Workshop zu erhalten: Fehler


Memory lock failed

(Speicher sperren nicht möglich)

Resource Workshop konnte den Speicher nicht sperren. Verlassen Sie Resource Workshop sofort, ohne Ihre Dateien zu sichern. Starten Sie Windows neu.


Could not allocate memory

(Speicher konnte nicht zugewiesen werden)

Resource Workshop konnte für eine Operation keinen Speicher erhalten. Verlassen Sie das Programm sofort, ohne Ihre Daten zu sichern. Schließen Sie andere Programme, um mehr Speicher für Resource Workshop zu erhalten.


Memory unlock failed

(Freigeben des Speichers fehlgeschlagen)

Resource Workshop konnte globalen Speicher nicht wieder freigeben. Verlassen Sie das Programm sofort, ohne Ihre Daten zu sichern. Starten Sie Windows neu.


File creation failed

(Dateierzeugung fehlgeschlagen)

Resource Workshop konnte eine Datei nicht anlegen.

Stellen Sie sicher, daß die angegebene Datei nicht bereits existiert und daß ausreichend Speicherplatz auf der Festplatte zur Verfügung steht. Wiederholen Sie dann die Operation, die den Fehler verursachte.


Could not open file

(Datei konnte nicht geöffnet werden)

Resource Workshop konnte die angegebene Datei nicht öffnen. Dieser Fehler kann auftreten, wenn Sie Ressourcen erstellt haben und diese in einer ausführbaren Datei (.EXE oder .DLL) speichern wollen, die nicht existiert.

Um das Problem zu beheben, stellen Sie sicher, daß die Datei existiert. Wiederholen Sie dann die Operation, die den Fehler verursachte.


File seek failed

(Fehler bei Positionierung des Dateizeigers)

Resource Workshop konnte die angegebene Stelle innerhalb einer Datei nicht auffinden.

Die Datei könnte fehlerhaft sein. Wiederholen Sie die Operation, die den Fehler verursachte, oder überprüfen Sie die Platte mit CHKDSK.


File read failed

(Fehler beim Lesen der Datei)

Resource Workshop konnte die angegebene Datei nicht lesen.

Stellen Sie sicher, daß die Datei existiert und lesbar ist. Wiederholen Sie dann die Operation, die den Fehler verursachte.


File write failed

(Fehler beim Schreiben in Datei)

Resource Workshop konnte nicht in die angegebene Datei schreiben.

Stellen Sie sicher, daß die Datei existiert und nicht schreibgeschützt ist. Prüfen Sie, ob genügend freier Speicherplatz auf der Festplatte vorhanden ist. Wiederholen Sie dann die Operation, die den Fehler verursachte.


Virtual table allocation failed

(Virtuelle Tabelle konnte nicht erzeugt werden)

Resource Workshop konnte keinen Speicher für eine virtuelle Tabelle anfordern. Verlassen Sie Resource Workshop sofort, ohne Ihre Daten zu sichern.

Schließen Sie andere Programme oder starten Sie Windows im erweiterten Modus, um mehr Speicher für Resource Workshop zu erhalten.


Virtual table put failed

(Virtuelle Tabelle sichern fehlgeschlagen)

Das interne Datenbanksystem von Resource Workshop arbeitet möglicherweise fehlerhaft. Verlassen Sie Resource Workshop sofort, ohne Ihre Daten zu sichern. Sie sollten auch Windows neu starten.


Virtual table read failed

(Virtuelle Tabelle lesen fehlgeschlagen)

Resource Workshop konnte die angegebene Datei nicht lesen.

Stellen Sie sicher, daß die Datei existiert und lesbar ist. Wiederholen Sie dann die Operation, die den Fehler verursachte.


Virtual table get failed

(Virtuelle Tabelle laden fehlgeschlagen)

Das interne Datenbanksystem von Resource Workshop arbeitet möglicherweise fehlerhaft. Verlassen Sie das Programm sofort, ohne Ihre Daten zu sichern. Sie sollten auch Windows neu starten.


Virtual table create failed

(Virtuelle Tabelle erstellen fehlgeschlagen)

Das interne Datenbanksystem von Resource Workshop arbeitet möglicherweise fehlerhaft. Verlassen Sie das Programm sofort, ohne Ihre Daten zu sichern. Sie sollten auch Windows neu starten.


Virtual table write failed

(Virtuelle Tabelle schreiben fehlgeschlagen)

Resource Workshop konnte nicht in die angegebene Datei schreiben.

Stellen Sie sicher, daß die Datei existiert und beschreibbar ist. Wiederholen Sie dann die Operation, die den Fehler verursachte.


Virtual table lock failed

(Virtuelle Tabelle sperren fehlgeschlagen)

Das interne Datenbanksystem von Resource Workshop arbeitet möglicherweise fehlerhaft. Verlassen Sie das Programm sofort, ohne Ihre Daten zu sichern. Sie sollten auch Windows neu starten.


Virtual buffer allocation failed

(Allokation des virtuellen Puffers fehlgeschlagen)

Resource Workshop konnte keinen Speicher für einen virtuellen Puffer anfordern.

Verlassen Sie das Programm sofort, ohne Ihre Daten zu sichern. Schließen Sie andere Programme, um mehr Speicher für Resource Workshop zu erhalten.


Virtual buffer lock failed

(Sperren des virtuellen Puffers fehlgeschlagen)

Das interne Datenbanksystem von Resource Workshop arbeitet möglicherweise fehlerhaft. Verlassen Sie das Programm sofort, ohne Ihre Daten zu sichern. Sie sollten auch Windows neu starten.


Binary too large

(Binärdatei zu groß)

Eine Binärdatei (Ressource oder Feld) ist so groß, daß Resource Workshop sie nicht compilieren kann.


Unexpected NULL pointer encountered

(Unerwarteter NULL-Zeiger gefunden)

Resource Workshop ist unerwartet auf einen NULL-Zeiger gestoßen.


Input source stack overflow

(Stacküberlauf bei Eingabe)

Resource Workshop konnte eine include- oder rcinclude-Datei nicht öffnen oder eine #define-Anweisung nicht erweitern. Es sind zu viele Dateien geöffnet oder zu viele #define-Anweisungen ineinander verschachtelt.


Cannot find resource

(Ressource nicht gefunden)

Resource Workshop konnte die ausgewählte Ressource nicht finden. Verlassen Sie sofort das Programm, ohne Ihre Daten zu sichern.


Unexpected file format

(Unerwartetes Dateiformat)

Dieser Fehler kann auftreten, wenn Resource Workshop:

 	eine binäre Ressource decompiliert. In diesem Fall zeigt die Fehlermeldung, daß der angegebene Ressourcentyp nicht mit den binären Daten übereinstimmt. Die Ressource wird bei der Decompilierung übergangen.

 	ein Programm oder eine dynamische Link-Bibliothek speichert. In diesem Fall handelt es sich nicht um eine Datei im Standardformat. Meist tritt dieser Fehler beim Speichern von Microsoft-Programmen wie Word für Windows auf, da diese nicht im standardmäßigen Programmformat vorliegen.


Unreleased version format

(Format einer nicht freigegebenen Version)

Die Datei, die Sie zu öffnen versuchen, wurde mit einer neueren Version von Resource Workshop erstellt.


Software error!

(Software-Fehler!)

Resource Workshop ist auf unerwartete Daten gestoßen. Verlassen Sie sofort das Programm, ohne Ihre Daten zu sichern. Sie sollten auch Windows neu starten.


Not implemented

(Nicht implementiert)

Die gewählte Funktion ist in dieser Version von Resource Workshop nicht implementiert.


You cannot use this identifier. It is a keyword, resource type name or resource name

(Dieser Bezeichner kann nicht verwendet werden. Es handelt sich um ein Schlüsselwort, einen Ressourcentyp oder einen Ressourcennamen)

Sie versuchen einen Bezeichner zu definieren, dessen Name schon für ein Schlüsselwort, einen Ressourcentyp oder -namen verwendet wird. Wählen Sie einen neuen, eindeutigen Namen.


Bad character in source input

(Ungültiges Zeichen in Eingabe)

Die angegebene Quelldatei enthält ein unbekanntes Zeichen.


#define text too long

(#define-Text ist zu lang)

Resource Workshop kann die Definition einer #define-Anweisung nicht speichern, da sie zu lang ist. Eine #define-Definition darf nicht mehr als 2000 Zeichen umfassen.


Invalid preprocessor directive

(Ungültige Präprozessor-Anweisung)

Resource Workshop ist auf ein # (Nummernzeichen) gestoßen, dem keine gültige Präprozessor-Direktive folgt.


Symbol already defined. Redefinition is not the same

(Symbol bereits definiert. Redefinition mit verändertem Namen)

Resource Workshop ist auf eine #define-Anweisung gestoßen, bei deren Namen es sich um ein Schlüsselwort handelt oder deren Definition nicht einer vorangegangenen Definition entspricht.

Obwohl zwei identische #define-Anweisungen übergangen werden, sind zwei unterschiedliche Definitionen für dieselbe #define-Anweisung nicht zulässig.


Expecting #define identifier

(#define-Bezeichner erwartet)

Resource Workshop ist auf eine #define-Anweisung gestoßen, der ein unzulässiger Name folgt. #define-Namen müssen mit einem Buchstaben beginnen und dürfen nur Ziffern, Buchstaben und Unterstriche enthalten.


'#else' before '#if'

('#else' vor '#if')

Resource Workshop ist auf eine #else- oder #elif-Anweisung gestoßen, zu der die dazugehörige #if-Anweisung fehlt. Korrigieren Sie diesen Syntaxfehler mit einem Texteditor.


'#endif' before '#if'

('#endif' vor '#if')

Resource Workshop ist auf eine #endif-Anweisung gestoßen, zu der die dazugehörige #if-Anweisung fehlt. Korrigieren Sie diesen Syntaxfehler mit einem Texteditor.


Unexpected end of file

(Unerwartetes Dateiende)

Das Dateiende wurde erreicht, während eine Compiler-Direktive (#if, #ifdef, usw.) verarbeitet wurde.


Expecting resource name or resource type name

(Name einer Ressource oder eines Ressourcentyps erwartet)

Resource Workshop ist auf einen nicht definierten Bezeichner oder Integer-Ausdruck gestoßen, der als Name oder als ID-Nummer einer Ressource eingestuft wurde. Statt des erwarteten Namens oder der ID-Nummer eines Ressourcentyps folgte jedoch ein anderer Ausdruck.


Expecting ')'

(")" erwartet)

In einem numerischen Ausdruck sind nicht alle Klammern geschlossen.


Expecting identifier

(Bezeichner erwartet)

Resource Workshop ist auf einen ungültigen Ausdruck in einer #ifdef- oder #if-Präprozessor-Anweisung gestoßen.


Expecting constant expression

(Konstantenausdruck erwartet)

Resource Workshop konnte einen Integer-Ausdruck nicht auswerten.


Expecting filename

(Dateiname erwartet)

Ein Dateiname (mit oder ohne Anführungszeichen) wird erwartet.


Expecting filename in quotes

(Dateiname (in Anführungszeichen) erwartet)

Einer #include-Anweisung folgte kein in Anführungszeichen oder spitzen Klammern eingeschlossener Dateiname.


Expecting a number or '('

(Zahl oder "(" erwartet)

Resource Workshop ist beim Parsen eines Integer-Ausdrucks auf ein unerwartetes Sprachelement gestoßen. Dieser Fehler wird oftmals von Schreibfehlern in Bezeichnernamen verursacht.


Expecting BEGIN

(BEGIN erwartet)

Resource Workshop ist auf ein unerwartetes Sprachelement gestoßen, obwohl das Schlüsselwort BEGIN hätte folgen sollen. Dieser Fehler wird oftmals von Schreibfehlern in Bezeichnernamen verursacht.


Expecting END

(END erwartet)

Resource Workshop ist auf ein unerwartetes Sprachelement gestoßen, als das Schlüsselwort END hätte folgen sollen. Dieser Fehler wird oftmals von Schreibfehlern in Bezeichnernamen verursacht.


Not a positive short integer

(Kein positiver Shortinteger)

Für Ressourcen- und Ressourcen-Typ-ID-Nummern müssen positive Shortinteger verwendet werden.


HEXSTRING over 255 bytes long

(HEXSTRING ist länger als 255 Bytes)

Ein Hexstring-Ausdruck ist länger als 255 Bytes. Diese in Resource Workshop gültige Sprach-erweiterung wird vom Microsoft-Ressourcen-Compiler nicht unterstützt.


Invalid value in HEXSTRING

(Unzulässiger Wert in HEXSTRING)

Eine Ressource des Typs Hexstring (eine Syntaxerweiterung in Resource Workshop, die vom Microsoft-Ressourcen-Compiler nicht unterstützt wird) besteht aus einer Reihe von Hexadezimalziffern und Whitespaces (Leerzeichen), die in Hochkommas eingeschlossen sind.

Resource Workshop ist innerhalb der Hochkommas auf ein Zeichen gestoßen, das nicht als Hexadezimalziffer interpretiert werden kann.


Field too large

(Feld ist zu groß)

Resource Workshop ist auf ein Datenfeld gestoßen, das mehr als 32K umfaßt.


PASCAL string over 255 bytes

(PASCAL-String ist länger als 255 Bytes)

Ein String im Pascal-Format darf nicht länger als 255 Bytes sein.


Cannot open file <filename>
Cannot open file:<filename>

(<Dateiname> kann nicht geöffnet werden)

Resource Workshop konnte die angegebene Datei nicht öffnen. Möglicherweise sind Ihre Zugriffsrechte für diese Datei nicht ausreichend.


Conflicting memory options

(Unvereinbare Speicheroptionen)

Es wurde eine Ressourcendefinition mit unvereinbaren Speicheroptionen gefunden.


String ID is already used

(String-ID-Nummer bereits vergeben)

Die ID-Nummern in den String-Tabellen eines Projekts dürfen im Projekt nur jeweils einmal vergeben werden.

Anmerkung:	Im Win32-Modus sind doppelte String-IDs in String-Tabellen erlaubt, für die verschiedene Sprachen angegeben wurden.


Resource of that name/ID, and type already exists

(Ressource dieser/s ID-Nummer/Namens und Typs bereits vorhanden)

Ressourcennamen oder ID-Nummern müssen innerhalb eines Ressourcentyps eindeutig vergeben werden.


Incomplete expression

(Unvollständiger Ausdruck)

Resource Workshop konnte einen Ausdruck nicht vollständig auswerten. Es können Zeichen falsch sein oder fehlen.


A MENU or POPUP must have at least one item

(Ein Menü bzw. Popup-Menü muß mindestens einen Eintrag enthalten)

Eine Menü- oder Popup-Menü-Definition muß zumindest einen Eintrag oder einen Separator enthalten. Fügen Sie Menü-Einträge hinzu oder wandeln Sie das Popup-Menü in einen Menü-Eintrag um.


An ACCELERATORS table must have at least one item

(Tastenkürzel-Tabelle muß mindestens einen Eintrag enthalten)

Sie können keine leere Tastenkürzel-Tabelle erstellen.


Invalid icon format

(Unzulässiges Symbolformat)

Resource Workshop konnte eine Symbolressource nicht compilieren, da sie in einem unzulässigen Dateiformat vorliegt.


Invalid cursor format

(Unzulässiges Mauszeiger-Format)

Resource Workshop konnte eine Mauszeiger-Ressource nicht compilieren, da sie in einem unzulässigen Format vorliegt.


Invalid bitmap format

(Unzulässiges Bitmap-Format)

Resource Workshop konnte eine Bitmap-Ressource nicht compilieren, da sie in einem unzulässigen Format vorliegt.


Expecting filename or BEGIN

(Dateiname oder BEGIN erwartet)

Resource Workshop konnte eine Datei oder eine Ressource nicht compilieren. Es wurde ein Dateiname, das Schlüsselwort BEGIN oder eine geschweifte Klammer erwartet.


#undef is not supported

(#undef wird nicht unterstützt)

Resource Workshop unterstützt kein #undef. Wenn die #undef-Definition in einer .H-Datei benötigt wird, um den Anforderungen eines C-Programms zu entsprechen, dann sollte der Ausdruck in eine #ifndef-Anweisung eingebettet werden.


L string prefix is not allowed

(L String-Präfix nicht zulässig)

Resource Workshop unterstützt L-markierte Strings nur in einer RCDATA-Anweisung. Stellen Sie sicher, daß sich der betreffende String in einer RCDATA-Anweisung befindet.


Expecting signed short integer

(Vorzeichenbehafteter Shortinteger erwartet)

Resource Workshop erwartet in diesem Feld einen vorzeichenbehafteten Shortinteger-Wert (16-Bit) oder -Ausdruck. Der Fehler wird normalerweise von einem undefinierten Bezeichner verursacht.


Expecting unsigned short integer

(Vorzeichenloser Shortinteger erwartet)

Resource Workshop erwartet in diesem Feld einen vorzeichenlosen Shortinteger-Wert (16-Bit) oder -Ausdruck. Der Fehler wird normalerweise von einem undefinierten Bezeichner verursacht.


Expecting signed long integer

(Vorzeichenbehafteter Longinteger erwartet)

Resource Workshop erwartet in diesem Feld einen vorzeichenbehafteten Longinteger-Wert (32-Bit) oder -Ausdruck. Der Fehler wird normalerweise von einem undefinierten Bezeichner verursacht.


Expecting unsigned long integer

(Vorzeichenloser Longinteger erwartet)

Resource Workshop erwartet in diesem Feld einen vorzeichenlosen Longinteger-Wert (32-Bit) oder -Ausdruck. Der Fehler wird normalerweise von einem undefinierten Bezeichner verursacht.


Expecting quoted string

(String (in Anführungszeichen) erwartet)

Resource Workshop erwartet in diesem Feld einen String (in Anführungszeichen).


Expecting resource ID or name

(Ressourcen-ID-Nummer oder -Name erwartet)

Resource Workshop erwartet einen positiven Shortinteger oder einen alphanumerischen Literal-Namen (ohne Anführungszeichen) als Ressourcenname oder Ressourcen-ID-Nummer.


Expecting resource type

(Ressourcen-Typ erwartet)

Resource Workshop erwartet einen positiven Shortinteger oder einen alphanumerischen Literal-Namen (ohne Anführungszeichen) als Ressourcentyp oder RessourcenID-Nummer.


Expecting class name or ID

(Klassenname oder -ID-Nummer erwartet)

Ein Dialogelement benötigt einen Namen in Anführungszeichen oder einen vorzeichenlosen Character-Wert mit einem Wert > 0x7F. Vorzeichenlose Character-Werte sind für Standard-Windows-Elemente reserviert.


Expecting HEXSTRING (hex digits surrounded by single quotes)

(HEXSTRING erwartet (Hex-Ziffern in Hochkommas))

Dem Schlüsselwort CTLDATA für ein Dialogelement muß ein HEXSTRING-Datenfeld folgen.


Invalid menu option

(Ungültige Menüoption)

Gültige Optionen für die Anweisungen POPUP oder MENUITEM sind:

CHECKED

MENUBREAK

MENUBARBREAK

INACTIVE

GRAYED

HELP

SEPARATOR (nur für MENUITEMs gültig)


Invalid accelerator option

(Ungültige Tastenkürzeloption)

Die folgenden Tastenkürzel-Optionen sind zulässig: ASCII, VIRTKEY, SHIFT, ALT, CONTROL und NOINVERT.


Invalid accelerator key value

(Ungültiger Wert für Tastenkürzel)

Tastenwerte für Tastenkürzel müssen folgendes enthalten:

Vorzeichenlose char-Werte

Einen String in Anführungszeichen, der einen vorzeichenlosen char-Wert und das Zeichen ^ zur Kennzeichnung von Steuertasten enthält.


Expecting caption: quoted string or unsigned integer

(Titel erwartet (in Anführungszeichen oder vorzeichenloser Integer))

Der Titel eines Dialogelements muß entweder aus einem String in Anführungszeichen oder einem vorzeichenlosen Shortinteger (16-Bit) bestehen.


String too long

(String ist zu lang)

Ein String in einer String-Tabelle darf nicht länger als 255 Bytes sein.


Expecting control window style

(Element-Fensterstil erwartet)

Die Elementdefinition in dieser Zeile besteht nicht aus einem vorzeichenlosen Longintegerwert (32 Bit) oder einem Ausdruck. Dieser Fehler wird normalerweise durch einen nicht definierten Stil-Bezeichner verursacht.


Expecting menu text (quoted string) or SEPARATOR

(Menütext (in Anführungszeichen) oder SEPARATOR erwartet)

Dem Schlüsselwort MENUITEM muß entweder ein String in Anführungszeichen (der Menüeintrag) oder das Schlüsselwort SEPARATOR folgen.


Compile initialization failed

(Compiler konnte nicht initialisiert werden)

Die Initialisierung des Compilers konnte nicht beendet werden. Verlassen Sie Resource Workshop und starten Sie sowohl Windows als auch Resource Workshop erneut.


Input reset failed

(Eingabe-Reset fehlgeschlagen)

Die Initialisierung des Compilers konnte nicht beendet werden. Verlassen Sie sowohl Resource Workshop als auch Windows und starten Sie diese Programme erneut.


Source input stack overflow (too many nested includes?)

(Stacküberlauf bei Eingabe (zu viele verschachtelte Include-Anweisungen?))

Es sind insgesamt mehr als 63 verschachtelte Include- oder #define-Anweisungen aufgetreten.


Parser stack overflow

(Parser-Stacküberlauf)

Die Schachtelungstiefe einer rekursiven Ressourcen-Definiton hat einen Grenzwert von Resource Workshop überschritten. Beispielsweise dürfen nicht mehr als 63 Popup-Menüs ineinander verschachtelt werden.


Expression stack overflow

(Stacküberlauf bei Ausdrücken)

Ein Integer-Ausdruck ist zu komplex, um von Resource Workshop ausgewertet werden zu können. Die maximale Schachtelungstiefe beträgt 32 Ebenen. Vereinfachen Sie den Ausdruck, indem Sie Klammern auflösen.


File IO error

(Ein-/Ausgabefehler (bei Dateien))

Beim Lesen einer Datei trat ein Fehler auf. Prüfen Sie, ob die Datei intakt ist.


New symbol failed

(Fehler beim Anlegen eines neuen Symbols)

Resource Workshop konnte eine #define-Anweisung nicht erzeugen. Dies deutet normalerweise auf Speichermangel hin.

Um herauszufinden, wieviel System-Speicher frei ist, wählen sie Start|Vorgaben|Steuerung und prüfen Sie das System. Danach prüfen Sie die Ausführungs-Tabelle.


New field instance failed

(Instantiierung des Feldes gescheitert)

Resource Workshop erhielt beim Erzeugen einer Feld-Struktur für eine Operation keinen Speicher zugewiesen. Verlassen Sie das Programm sofort, ohne Ihre Daten zu sichern.

Schließen Sie andere Programme, um mehr Speicher für Resource Workshop zu erhalten.


Allocate failed

(Fehler bei Zuweisung)

Resource Workshop erhielt für eine Operation keinen Speicher zugewiesen. Verlassen Sie das Programm sofort, ohne Ihre Daten zu sichern.

Schließen Sie andere Programme, um mehr Speicher für Resource Workshop zu erhalten.


Memory lock failed

(Fehler beim Sperren von Speicher)

Resource Workshop konnte den Speicher nicht sperren. Verlassen Sie sofort das Programm, ohne Ihre Daten zu sichern. Sie sollten auch Windows neu starten.


VTMgr allocation error

(Fehler bei Speicherzuweisung (VTMgr))

Resource Workshop erhielt für eine Operation keinen Speicher zugewiesen. Verlassen Sie das Programm sofort, ohne Ihre Daten zu sichern.

Schließen Sie andere Programme, um mehr Speicher für Resource Workshop zu erhalten.


VTMgr lock error

(Fehler beim Sperren von Speicher (VTMgr))

Resource Workshop konnte den Speicher nicht sperren. Verlassen Sie sofort das Programm, ohne Ihre Daten zu speichern. Sie sollten auch Windows neu starten.


VBuff allocation error

(Fehler bei Zuweisung des Puffers (VBuff))

Resource Workshop erhielt für eine Operation keinen Speicher zugewiesen. Verlassen Sie das Programm sofort, ohne Ihre Daten zu sichern.

Schließen Sie andere Programme, um mehr Speicher für Resource Workshop zu erhalten.


VBuff lock error

(Fehler beim Sperren des Puffers (VBuff))

Resource Workshop konnte den Speicher nicht sperren. Verlassen Sie sofort das Programm, ohne Ihre Daten zu sichern. Sie sollten auch Windows neu starten.


Internal software error

(Interner Software-Fehler)

Resource Workshop ist auf unerwartete Daten gestoßen. Verlassen Sie sofort das Programm, ohne Ihre Daten zu sichern. Sie sollten auch Windows neu starten.


Device dependent bitmap does not match current display. Cannot convert

(Geräteabhängige Bitmap für diesen Bildschirmtyp nicht geeignet. Konvertierung nicht möglich)

Sie versuchen eine Windows 2.0-Ressource mit einer geräteabhängigen Bitmap zu öffnen, das Format der Bitmap entspricht jedoch nicht dem verwendeten Bildschirmtyp. Konvertieren Sie die Bitmap mit einem geeigneten Hilfsprogramm.


Preprocessor directives not allowed

(Präprozessor-Anweisungen nicht erlaubt)

Präprozessor-Anweisungen sind nicht erlaubt, wenn Sie eine Ressource als Text bearbeiten. Um diese hinzuzufügen, bearbeiten Sie die Ressource enthaltende Datei als Textdatei.


Too much data for 1 field

(Maximale Datenmenge in einem Feld erreicht)

Sie haben in diesem Feld mehr Daten eingegeben als der Compiler verarbeiten kann. Der Fehler kann auch durch ein ungültiges Zeichen verursacht sein, welches der Compiler als zusätzliches Sprachelement interpretiert. Löschen Sie überschüssige Daten.


Cannot convert Windows 2 image: file is read-only

(Windows-2-Bild kann nicht konvertiert werden: Datei ist schreibgeschützt)

Sie haben eine Ressource geöffnet, die eine Bitmap im Windows-2-Format beinhaltet. Die Ressourcen-Datei ist jedoch schreibgeschützt. Ändern Sie die Dateiattribute, um die Bitmap in Resource Workshop bearbeiten zu können.


Too many controls

(Zu viele Elemente)

Eine Dialogfensterressource enthält mehr als 255 Elemente. Es sind nur 255 Elemente pro Dialogfensterentwurf erlaubt.


Invalid escape sequence

(Unzulässige Escape-Sequenz)

Dem Backslash-Zeichen ('\') in einem String folgte keine gültige Escape-Sequenz.


Too many digits in a number

(Zahl enthält zu viele Ziffern)

Die Zahl enthält zu viele Ziffern und überschreitet deshalb den Zahlenbereich eines vorzeichenlosen 32-Bit-Integers.


Expecting unit keyword

(Schlüsselwort UNIT erwartet)

Resource Workshop ist auf einen unbekannten Ausdruck gestoßen, als eigentlich das Schlüsselwort UNIT hätte folgen sollen. Vergewissern Sie sich, daß die Include- oder Unit-Datei keine syntaktischen Fehler aufweist, indem Sie die Datei compilieren.


Expecting semicolon

(Semikolon erwartet)

Resource Workshop ist auf einen unbekannten Ausdruck gestoßen, als eigentlich ein Semikolon hätte folgen sollen. Vergewissern Sie sich, daß die Include- oder Unit-Datei keine syntaktischen Fehler aufweist, indem Sie die Datei compilieren.


Expecting interface keyword

(Schlüsselwort INTERFACE erwartet)

Resource Workshop ist auf einen unbekannten Ausdruck gestoßen, als eigentlich das Schlüsselwort INTERFACE hätte folgen sollen. Vergewissern Sie sich, daß die Include- oder Unit-Datei keine syntaktischen Fehler aufweist, indem Sie die Datei compilieren.


Must be first token on a line

(Muß erster Bezeichner in einer Zeile sein)

Eine Präprozessor-Anweisung oder eine Konstante muß als erster Ausdruck in einer Quelltextzeile stehen. Korrigieren Sie den Quelltext mit einem Texteditor.


Pascal syntax error (unrecognized token)

(Pascal-Syntaxfehler (unbekannter Bezeichner))

Resource Workshop ist auf ein unbekanntes Sprachelement gestoßen. Vergewissern Sie sich, daß die Include- oder Unit-Datei keine syntaktischen Fehler aufweist, indem Sie die Datei compilieren.


Unexpected const keyword

(Unerwartetes Schlüsselwort CONST)

Resource Workshop ist unerwartet auf das Schlüsselwort CONST gestoßen. Vergewissern Sie sich, daß die Include- oder Unit-Datei keine syntaktischen Fehler aufweist, indem Sie die Datei compilieren.


Unexpected operator

(Unerwarteter Operator)

Resource Workshop ist auf einen unerwarteten Operator gestoßen. Vergewissern Sie sich, daß die Include- oder Unit-Datei keine syntaktischen Fehler aufweist, indem Sie die Datei compilieren.


#error directive encountered: <error message>

(#error-Direktive aufgetreten: <Fehlermeldung>)

Der Ressourcen-Compiler von Resource Workshop ist auf eine #error-Anweisung gestoßen. Der Text der benutzerdefinierten Fehlermeldung wird nun angezeigt.


Not a valid identifier name

(Kein gültiger Bezeichnername)

Der Name in einer #define-Anweisung oder in einer Konstantendeklaration ist syntaktisch nicht korrekt. Bezeichnernamen müssen mit einem Buchstaben beginnen und dürfen nur Ziffern, Buchstaben und Unterstriche enthalten.


Resource binary too large

(Binäre Ressource zu groß)

Die binäre Ressourcendatei, die Sie öffnen wollen, ist zu groß für die Bearbeitung mit Resource Workshop.


Syntax error

(Syntaxfehler)

Ein Syntaxfehler ist aufgetreten. Überprüfen Sie die Syntax des Ressourcen-Scripts und compilieren Sie es erneut.


Token is too large for scanner (unbalanced quotes?)

(Sprachelement für Scanner zu lang (fehlendes Anführungszeichen?))

Der Scanner hat beim Versuch, einen String oder Hexstring einzulesen, kein abschließendes Hochkomma oder Anführungszeichen gefunden. Prüfen Sie im Ressourcen-Script die Anzahl dieser Zeichen.


Unterminated string or hexdecimal constant

(Nicht terminierte String- oder hexadezimale Konstante)

Einer String- oder hexadezimalen Konstanten in einer Ihrer Ressourcen fehlt entweder das schließende Anführungszeichen oder das Fortsetzungszeichen (/) am Ende der Zeile.


Expecting "]"

("]" erwartet)

Der Ressourcen-Compiler fand einen Syntaxfehler in der .RC-Datei.


Expecting field type

(Feldtyp erwartet)

Der Ressourcen-Compiler fand einen Syntaxfehler in der .RC-Datei.


Expecting RESEND

(RESEND erwartet)

Der Ressourcen-Compiler fand einen Syntaxfehler in der .RC-Datei.


Expecting field name, field type or function keyword

(Feldname, Feldtyp oder Schlüsselwort function erwartet)

Der Ressourcen-Compiler fand einen Syntaxfehler in der .RC-Datei.


Expecting RESPARENT or RESITEMCOUNT

(RESPARENT oder RESITEMCOUNT erwartet)

Der Ressourcen-Compiler fand einen Syntaxfehler in der .RC-Datei.


Field name already used

(Feldname bereits verwendet)

Der Ressourcen-Compiler fand einen Semantikfehler in der .RC-Datei.


Object is read only

(Objekt darf nur gelesen werden)

Der Resource Workshop konnte eine Datei nicht zurückschreiben, da sie für Schreibzugriffe gesperrt ist oder von einem anderen Prozeß verwendet wird.


Only one unnamed item allowed

(Nur ein unbezeichneter Begriff zulässig)

Der Ressourcen-Compiler fand einen Semantikfehler in der .RC-Datei.


Optional field keyword already used

(Ein optionales Feldschlüsselwort wird bereits verwendet)

Der Ressourcen-Compiler fand einen Semantikfehler in der .RC-Datei.


Duplicate EDITDATA keyword

(Schlüsselwort EDITDATA doppelt)

Der Ressourcen-Compiler fand einen Semantikfehler in der .RC-Datei.


Duplicate RESBIN keyword

(Schlüsselwort RESBIN doppelt)

Der Ressourcen-Compiler fand einen Semantikfehler in der .RC-Datei.


Duplicate RESITEM keyword

(Schlüsselwort RESITEM doppelt)

Der Ressourcen-Compiler fand einen Semantikfehler in der .RC-Datei.


Positional optional fields must preceed keyword optional fields
Positional optional fields must precede keyword optional fields

(Positionsungebundene Felder müssen vor Schlüsselwort-Feldern stehen)

Die Angaben in der markierten Zeile sind nicht korrekt. Prüfen Sie auf Schreib- oder Eingabefehler.


Item keyword already used

(Schlüsselwort des Eintrags bereits verwendet)

Die Angaben in der markierten Zeile sind nicht korrekt. Prüfen Sie auf Schreib- oder Eingabefehler.


Field definitions not allowed

(Feld-Definitionen nicht zulässig)

Die Angaben in der markierten Zeile der .RC-Datei sind nicht korrekt. Prüfen Sie auf Schreib- oder Eingabefehler.


RESBIN definitions not defined

(RESBIN nicht definiert)

Die Angaben in der markierten Zeile sind nicht korrekt. Prüfen Sie auf Schreib- oder Eingabefehler.


RESBIN definitions not allowed

(RESBIN-Definitionen nicht zulässig)

Die Angaben in der markierten Zeile sind nicht korrekt. Prüfen Sie auf Schreib- oder Eingabefehler.


RESITEM definitions not allowed

(RESITEM-Definitionen nicht zulässig)

Der Ressourcen-Compiler ist auf einen Semantikfehler in der .RC-Datei gestoßen.


'|=' default value not allowed for an array

('|=' Standardwert; für ein Array nicht zulässig )

Der Ressourcen-Compiler fand einen Semantikfehler in der .RC-Datei.


'|=' default value not supported for this field type

('|=' Standardwert; für diesen Feldtyp nicht unterstützt )

Der Ressourcen-Compiler fand einen Semantikfehler in der .RC-Datei.


Item names cannot be reserved words

(Namen von Einträgen können keine reservierten Worte sein )

Der Ressourcen-Compiler fand einen Syntaxfehler in der .RC-Datei.


Nested default values not allowed

(Geschachtelte Standardwerte nicht zulässig )

Der Ressourcen-Compiler fand einen Semantikfehler in der .RC-Datei.


Expecting a valid file extension (3 letters or less)

(Es wird eine gültige Dateierweiterung (1-3 Zeichen) erwartet )

Der Ressourcen-Compiler fand einen Semantikfehler in der .RC-Datei.


Fonts must have numerics resource IDs

(Fonts müssen numerische Ressourcen-Bezeichner haben)

Font-Namen müssen numerische Ressourcen-Bezeichner haben. Andere Ressourcen können entweder eine Nummer oder einen String als Identifikation verwenden.


Invalid font format

(Fehlerhaftes Font-Format )

Die in der FONT-Ressource spezifizierte Datei ist keine gültige Schriften-Datei oder ist nicht lesbar.


Expecting signed character

(Vorzeichenbehaftetes Zeichen erwartet )

Der Ressourcen-Compiler fand einen Syntaxfehler in der .RC-Datei.


Expecting unsigned character

(Vorzeichenloses Zeichen erwartet )

Der Ressourcen-Compiler fand einen Syntaxfehler in der .RC-Datei.


Invalid font specification

(Fehlerhafte Schriftspezifikation )

Ein Font in der Schriften-Datei ist fehlerhaft. Versuchen Sie, die Schriften nochmals zu installieren.


Fatal error

(Nicht behebbarer Fehler )

Der Fehler ist so gravierend, daß der Ressourcen-Compiler die Verarbeitung des Ressourcen-Scripts nicht fortsetzen kann.


Identifier is out of scope

(Bezeichner außerhalb des Gültigkeitsbereichs)

Ein Bezeichner, der in einem Makro verwendet wird, wurde mit einer #undef-Anweisung versehen.


Expecting window rectangle (4 signed long integers)

(Fensterrechteck erwartet (4 Longinteger mit Vorzeichen))

Ein Dialogelement benötigt 4 vorzeichenlose Integerwerte für die Angabe seiner Position und Größe.

Der Ressourcen-Compiler fand nicht genug Werte in der Ressourcen-Definition. Dialogfenster und ihre Steuerelemente erfordern die Position x und y der oberen linken Ecke, gefolgt von der Breite und Höhe der Ressource in Integern.


User break

(Benutzerunterbrechung)

Während der Compilierung wurde der Abbruchschalter betätigt.


Height must be from 1 to 32767
Height must be from 1 to 5000

(Höhe muß zwischen 1 und 5000 liegen)

Sie haben eine ungültige Höhe angegeben. Geben Sie einen Wert zwischen 1 und 5000 ein.


Bitmap must contain less than <some number> of pixels

(Bitmap muß weniger als <Anzahl> an Pixeln enthalten)

Die Bitmap ist zu groß für die Bearbeitung im Ressource Workshop.


Width must be from 1 to 5000

(Breite muß zwischen 1 und 5000 liegen)

Sie haben eine ungültige Breite angegeben. Geben Sie einen Wert zwischen 1 und 5000 ein.


Unable to load Bitmap editor

(Laden des Bitmap-Editors nicht möglich)

Ressource Workshop ist nicht in der Lage, den Bitmap-Editor zu laden, da die DLL fehlt oder die Speicherausstattung extrem niedrig ist.


Horizontal (x) must be from 1 to 31

(Die Horizontale (x) muß zwischen 1 und 31 liegen)

Wenn Sie einen Kontaktpunkt für einen Mauszeiger setzen, muß die x-Koordinate zwischen 1 und 31 liegen. Das bedeutet, daß sie einen Punkt auf dem Mauszeiger auswählen müssen.


Vertical (y) must be from 1 to 31

(Die Vertikale (y) muß zwischen 1 und 31 liegen)

Wenn Sie einen Kontaktpunkt für einen Mauszeiger setzen, muß die y-Koordinate zwischen 1 und 31 liegen. Das bedeutet, daß sie einen Punkt auf dem Mauszeiger auswählen müssen.


Unable to load Cursor editor

(Laden des Mauszeiger-Editors nicht möglich)

Ressource Workshop ist nicht in der Lage, den Mauszeiger-Editor zu laden, da die DLL fehlt oder die Speicherausstattung extrem niedrig ist.


The file <filename> is already in this project. You cannot use the file.

(Die Datei <Dateiname> existiert bereits in diesem Projekt. Sie können die Datei nicht verwenden.)

Es existiert bereits eine Datei mit dem für eine Ressource spezifizierten Namen. Sie wird im aktuellen Projekt auch benutzt. Wenn Sie die bestehende Ressourcen-Datei ändern wollen, suchen Sie den entsprechenden Projekteintrag und bearbeiten Sie sie. Wollen Sie eine neue Datei erzeugen, verwenden Sie einen eindeutigen Namen.


 Icon dimensions must be from 1 to 255

(Die Ausdehnungen eines Symbols müssen zwischen 1 und 255 liegen)

Symbole können 255x255 Bildpunkte nicht überschreiten. Für Bitmaps besteht diese Einschränkung nicht.


Unable to load Icon editor

(Laden des Symbol-Editors nicht möglich)

Ressource Workshop ist nicht in der Lage,den Symbol-Editor zu laden, da die DLL fehlt oder die Speicherausstattung extrem niedrig ist.


This image has too many colors to edit

(Dieses Bild enthält zu viele Farben für die Bearbeitung)

Das Bild enthält mehr als 256 Farben.


This image has too many colors to edit on this display

(Dieses Bild enthält zu viele Farben für die Bearbeitung auf diesem Bildschirm)

Das Bild enthält mehr Farben als auf diesem Bildschirm bearbeitet werden können. Verwenden sie die Steuerleiste, um die Anzahl der unterstützten Farben zu ändern. In Abhängigkeit vom Bildschirm kann es notwendig sein, die Auflösung zu verändern.


An image of this type exists. Continue?

(Ein Bild dieses Typs existiert. Fortsetzen?)

Eine Version des Symbols oder des Mauszeigers mit der gleichen Breite, Höhe und Anzahl Farben existiert bereits.


This image has an unknown format

(Das Bild hat ein unbekanntes Format)

Das Bild ist kein standardmäßiges Bitmap-Format von Windows.


File <filename> does not exist
<filename> does not exist. Do you wish to create it?

(<Dateiname> nicht vorhanden. Erzeugen?)

Die angegebene Datei existiert nicht im angegebenen Pfad. Überprüfen Sie das Verzeichnis und die Schreibweise des Dateinamens.


Resource has changed. Do you wish to save it?
Resource project has changed. Do you wish to save it?

(Das Ressourcen-Projekt wurde geändert. Sichern?)

Die Ressource, an der Sie gerade arbeiten, wurde verändert. Wenn Sie keine Compilierung vornehmen lassen, werden die Änderungen verworfen.

Wählen Sie Abbruch, um zu Ressource Workshop zurückzukehren, ohne die Änderungen zu verlieren und ohne Dateien zu speichern.


Delete resource: <resource name>

(Löschen der Ressource: <Ressourcen-Name>)

Die gewählte Ressource soll gelöscht werden. Klicken Sie auf "Ja", wenn Sie sie löschen wollen. Klicken Sie auf "Nein", wenn sie nicht gelöscht werden soll.


Could not load library

(Bibliothek konnte nicht geladen werden)

Ressource Workshop konnte eine der benötigten Bibliotheken nicht laden.

Tritt der Fehler auf, prüfen Sie auch, wieviel Arbeitsspeicher zur Verfügung steht. Steht wenig Speicherplatz zur Verfügung, schließen Sie eine andere Anwendung.


Could not load one of the Dialog editor libraries

(Dialogeditor-Bibliothek konnte nicht geladen werden)

Ressource Workshop konnte eine der benötigten Bibliotheken für den Dialog-Editor nicht laden. Diese wurde nicht gefunden, oder Ihr Computer ist mit zu wenig Arbeitsspeicher ausgestattet.


<filename> does not exist

(<Dateiname> nicht vorhanden)

Die angegebene Programmdatei oder dynamische Link-Bibliothek existiert nicht. Ressource Workshop kann jedoch keine Programmdateien erzeugen, sondern den Dateien lediglich Ressourcen hinzufügen.


A resource of that name already exists

(Ressource dieses Namens bereits vorhanden)

Der gewählte Name wird schon von einer anderen Ressource verwendet. Wählen Sie einen anderen Namen.


Identifier already exists

(Bezeichner bereits vorhanden)

Der angegebene Bezeichnername existiert bereits. Verwenden Sie einen eindeutigen Namen.

Beachten Sie bitte, daß bei #define-Anweisungen in C/C++ zwischen Groß- und Kleinschreibung unterschieden wird, bei Pascal-Konstanten jedoch nicht.


Selected file <filename> already exists. Do you wish to overwrite it?
Selected file <filename) already exists. Do you wish to overwrite it?

(Ausgewählte Datei <Dateiname> existiert bereits. Überschreiben?)

Eine Datei des angegebenen Typs und Namens ist im Projekt bereits vorhanden. Ressourcen-Namen und -ID-Nummern müssen innerhalb eines Projekt und eines Typs eindeutig sein. Geben Sie einen Namen oder eine ID-Nummer an, der noch nicht für eine Ressource diesen Typs verwendet wird.

Anmerkung:	Im Win32-Modus müssen Ressourcennamen und IDs nur innerhalb eines gegebenen Typs und einer Sprache eindeutig sein.


<filename> exists. Overwrite?

(<Dateiname> bereits vorhanden. Überschreiben?)

Sie versuchen, in eine bereits bestehende Datei zu speichern. Wählen Sie Ja, wenn Sie den Inhalt der Datei überschreiben möchten. Wählen Sie Abbruch, um den Vorgang abzubrechen und zu Ressource Workshop zurückzukehren.


<filename> does not exist. Create?

(<Dateiname> nicht vorhanden. Erzeugen?)

Die angegebene Datei existiert nicht. Klicken Sie auf "Ja", wenn Sie eine neue Datei erzeugen möchten.


Error creating file <filename>

(Fehler beim Erzeugen der Datei <Dateiname>)

Ressource Workshop konnte die neue Datei nicht erzeugen. Ist der Dateiname gültig, versuchen Sie die Aktion nochmals. Prüfen Sie, wieviel Platz auf dem Bestimmungs-Laufwerk vorhanden ist und ob es andere Laufwerksprobleme gibt.

Tritt der Fehler weiterhin auf, prüfen Sie auch, wieviel Arbeitsspeicher zur Verfügung steht. Steht wenig Speicherplatz zur Verfügung, schließen Sie eine andere Anwendung.


You cannot undo this action! Select cancel to stop

(Diese Aktion kann nicht rückgängig gemacht werden! Wählen Sie Abbruch, um abzubrechen)

Die Aktion, die Sie gerade ausführen wollen, kann nicht rückgängig gemacht werden! Dies ist die letzte Gelegenheit zum Abbruch.


Remove contents of <filename> from this project?

(Inhalte von <Dateiname> aus diesem Projekt entfernen?)

Wenn Sie Ja wählen, werden alle Ressourcen und/oder Bezeichner in der ausgewählten Datei sowie in allen mit dieser Datei verbundenen Dateien aus dem Projekt entfernt.

Da Sie diese Aktion nicht rückgängig machen können, erscheint eine Warnung, sobald Sie Ja gewählt haben.

Sie lautet:

Diese Aktion kann nicht rückgängig gemacht werden! Wählen Sie Abbruch, um abzubrechen


Division by zero is not allowed

(Division durch Null ist unzulässig)

In einem Ausdruck oder einer Funktion ist eine Division durch Null enthalten. Dies ist nicht zulässig: Ändern Sie den Ausdruck oder die Funktion.


Please close window
Please close a window

(Schließen Sie bitte ein Fenster)

Es dürfen in Ressource Workshop nur 10 Editorfenster gleichzeitig geöffnet sein. Bevor Sie ein weiteres Fenster öffnen können, schließen Sie bitte eines der momentan geöffneten Fenster. Um das aktive Editorfenster zu schließen, drücken Sie Strg+F4.


Resource type already exists

(Ressourcentyp bereits vorhanden)

Sie versuchen einen neuen Ressourcentyp zu erzeugen, der bereits existiert. Wählen Sie einen eindeutigen Namen oder ID-Wert.

Beachten Sie bitte, daß die ID-Nummern von benutzerdefinierten Ressourcentypen größer als 256 sein sollten, da die Werte 1 bis 256 für den Hersteller des Betriebssystems reserviert sind.


Invalid addon module (check installation.)

(Fehlerhafter Lademodul (Installation überprüfen))

Ressource Workshop kann nicht starten. Entweder fehlen für die Installation notwendige Dateien oder Ihr Computer hat extrem wenig Speicher.


Out of memory (increase swap file or RAM size.)

(Außerhalb des Speichers (vergrößern Sie die Auslagerungsdatei oder die RAM-Größe))

Wenn dieser Fehler auftritt, sollten Sie prüfen, wieviel Arbeitsspeicher zur Verfügung steht. Steht wenig Speicherplatz zur Verfügung, schließen Sie eine andere Anwendung.


Invalid range for value, must be between number and number
Invalid range for value, must be between <number> and <number>

(Fehlerhafte Wertefolge, muß zwischen <Zahl> und <Zahl> liegen)

Der Wert, der für eine Option in Datei|Projekt eingegeben wurde, liegt außerhalb der Gültigkeitsgrenzen.


Missing Help file <filename>

(Hilfe-Datei <Dateiname>fehlt)

Die Hilfe-Datei konnte nicht gefunden werden. Sie wurde entweder gelöscht oder ist in einem von \HELP unterschiedlichen Verzeichnis enthalten..


Unexpected end of file in conditional started on line <line number>

(Unerwartetes Ende der bedingt auf Zeile <Zeilennummer> gestarteten Datei )

Eine #ifdef- oder #ifndef-Anweisung auf der spezifizierten Zeilennumer hat keine zugehörige #endif-Anweisung


User Break

Sie haben während der Kompilierung eines Programms STRG-PAUSE gedrückt. (Dies ist keine Fehlermeldung, sondern nur eine Bestätigung.)


Unknown error (# errornum)

Interner Compiler-Fehler. Wenden Sie sich an den technischen Support von Borland.


Link terminated by user

Sie haben das Linken abgebrochen. (Dies ist keine Fehlermeldung, sondern nur eine Bestätigung.)


Fatal Error: Cannot Load Linker: linker

Sie versuchen eine Version des Linkers zu laden, die nicht mit dieser Version von C++Builder kompatibel ist. Versuchen Sie C++Builder neu zu installieren oder wenden Sie sich an den technischen Support von Borland.


Fatal Error: Linker missing CREATE Entry Point

Sie versuchen eine Version des Linkers zu laden, die nicht mit dieser Version von C++Builder kompatibel ist. Versuchen Sie C++Builder neu zu installieren oder wenden Sie sich an den technischen Support von Borland.


Fatal Error: Linker missing DESTROY Entry Point

Sie versuchen eine Version des Linkers zu laden, die nicht mit dieser Version von C++Builder kompatibel ist. Versuchen Sie C++Builder neu zu installieren oder wenden Sie sich an den technischen Support von Borland.


Fatal Error: Linker CREATE Failed

Sie versuchen eine Version des Linkers zu laden, die nicht mit dieser Version von C++Builder kompatibel ist. Versuchen Sie C++Builder neu zu installieren oder wenden Sie sich an den technischen Support von Borland.


Cannot find tasm program: tasm32.exe

Sie versuchen, Code zu linken, der Assembler-Sprachdirektiven enthält, aber C++Builder kann Asembler nicht auf Ihrem System finden. Turbo Assembler (tasm.32) von Borland ist ein eigenes Produkt, das Sie zusätzlich zu C++Builder erwerben müssen. Falls Turbo Assembler auf Ihrem System installiert ist, überprüfen Sie, ob es im Pfad enthalten ist.


Unknown fatal error

Interner Ressourcen-Compiler-Fehler. C++Builder hat den Compiler geladen, aber er kann nicht ausgeführt werden. Die Kompilierung wurde abrupt abgebrochen. Wenden Sie sich an den technischen Support von Borland.


Unable to load RW32CORE.DLL

Interner Ressourcen-Compiler-Fehler. C++Builder konnte die Ressourcen-Compiler-DLL (RW32CORE.DLL) nicht laden, weil sie entweder nicht vorhanden ist, zu wenig Arbeitsspeicher zur Verfügung steht oder die DLL beschädigt ist. Wenden Sie sich an den technischen Support von Borland.


Cannot locate file I/O hook functions for resource compiler

C++Builder hat eine Version der RW32CORE.DLL geladen, aber aus irgendeinem Grund ist es nicht die korrekte Version. Dies könnte vorkommen, wenn Sie unbeabsichtigt eine Version der RW32CORE.DLL von Borland C++ 5.0 oder 5.01 anstelle der von C++Builder geladen haben. Installieren Sie C++Builder neu.